sprk_exchange.h
1 // Copyright (c) Tech Soft 3D, Inc.
2 //
3 // The information contained herein is confidential and proprietary to Tech Soft 3D, Inc.,
4 // and considered a trade secret as defined under civil and criminal statutes.
5 // Tech Soft 3D, Inc. shall pursue its civil and criminal remedies in the event of
6 // unauthorized use or misappropriation of its trade secrets. Use of this information
7 // by anyone other than authorized employees of Tech Soft 3D, Inc. is granted only under
8 // a written non-disclosure agreement, expressly prescribing the scope and manner of such use.
9 
10 #ifndef SPRK_EXCHANGE_H
11 #define SPRK_EXCHANGE_H
12 
13 #include "sprk.h"
14 
15 typedef void A3DEntity;
16 typedef void A3DAsmModelFile;
17 typedef void A3DRWParamsPrcReadHelper;
18 
19 #ifdef _MSC_VER
20 #ifndef STATIC_APP
21 # ifdef SPRK_EXCHANGE
22 # define EXCHANGE_API __declspec (dllexport)
23 # else
24 # define EXCHANGE_API __declspec (dllimport)
25 # endif
26 #endif
27 #else
28 # include <stddef.h>
29 # if defined(LINUX_SYSTEM) && defined(SPRK_EXCHANGE)
30 # ifndef STATIC_APP
31 # define EXCHANGE_API __attribute__ ((visibility ("default")))
32 # endif
33 # endif
34 #endif
35 
36 #ifndef EXCHANGE_API
37 # define EXCHANGE_API
38 #endif
39 
40 namespace HPS
41 {
42 
44 class EXCHANGE_API Exchange
45 {
46 public:
47 
48  class Component;
49  class Configuration;
50  class Sheet;
51  class TessellationOptionsKit;
52  class TranslationNotifier;
53  class TranslationOptionsKit;
54 #if !defined(TARGET_OS_ANDROID)
55  class ExportParasolidOptionsKit;
56 #endif
57  class ReloadNotifier;
58 
59  typedef std::vector<Configuration, HPS::Allocator<Configuration> > ConfigurationArray;
60  typedef std::vector<Sheet, HPS::Allocator<Sheet> > SheetArray;
61  typedef HPS::IntArray ParasolidEntityArray;
62 
65  enum class Units
66  {
67  Unknown,
68  Point,
69  Inch,
70  Millimeter,
71  Centimeter,
72  Pica,
73  Foot,
74  Yard,
75  Meter,
76  Kilometer,
77  Mile
78  };
79 
82  enum class UnloadMode
83  {
86  ExchangeAndVisualization,
87 
92  ExchangeOnly,
93  };
94 
97  enum class LoadStatus
98  {
100  Unknown,
102  Loaded,
104  VisualizationOnly,
106  PartiallyLoaded,
108  NotLoaded
109  };
110 
113  class EXCHANGE_API Component : public HPS::Component
114  {
115  public:
117  Component();
118 
122  Component(HPS::Component const & in_that);
123 
126  Component(Exchange::Component const & in_that);
127 
130  Component(Exchange::Component && in_that);
131 
132  virtual ~Component();
133 
134  static const HPS::Type staticType = HPS::Type::ExchangeComponent;
135  HPS::Type ObjectType() const { return staticType; }
136 
137 #if !defined(_MSC_VER) || _MSC_VER >= 1900
138  Component & operator=(Component const & in_that) = default;
139 #endif
140 
144  Component & operator=(Exchange::Component && in_that);
145 
146 
149  A3DEntity * GetExchangeEntity() const;
150 
151 
157  void Tessellate(TessellationOptionsKit const & in_options);
158 
165  TranslationNotifier Translate(Units in_units, TranslationOptionsKit const & in_translation_options);
166 
173  ReloadNotifier Reload(TessellationOptionsKit const & in_tessellation_options = TessellationOptionsKit(), TranslationOptionsKit const & in_translation_options = TranslationOptionsKit());
174 
179  bool SetTransform(MatrixKit const & in_transform);
180 
185  bool AddTransform(MatrixKit const & in_transform);
186 
195  HPS::Component CopyTo(HPS::Component const & in_new_owner);
196 
200  bool SetName(char const * in_new_name);
201  };
202 
203  class EXCHANGE_API ProductOccurrence : public Exchange::Component
204  {
205  public:
207  ProductOccurrence();
208 
212  ProductOccurrence(HPS::Component const & in_that);
213 
217  ProductOccurrence(Component const & in_that);
218 
221  ProductOccurrence(ProductOccurrence const & in_sheet);
222 
226  ProductOccurrence(ProductOccurrence && in_that);
227 
231  ProductOccurrence & operator=(ProductOccurrence && in_that);
232 
233  virtual ~ProductOccurrence();
234 
235  static const HPS::Type staticType = HPS::Type::ExchangeProductOccurrence;
236  HPS::Type ObjectType() const { return staticType; }
237 
241  bool Equals(ProductOccurrence const & in_kit) const;
242 
246  bool operator==(ProductOccurrence const & in_kit) const;
247 
251  bool operator!=(ProductOccurrence const & in_kit) const;
252 
258  void Unload(UnloadMode in_mode = UnloadMode::ExchangeAndVisualization);
259 
265  LoadStatus GetLoadStatus() const;
266 
270  bool IsExternalData() const;
271  };
272 
274  class EXCHANGE_API Sheet : public Exchange::Component
275  {
276  public:
278  Sheet();
279 
283  Sheet(HPS::Component const & in_that);
284 
288  Sheet(Component const & in_that);
289 
292  Sheet(Sheet const & in_sheet);
293 
297  Sheet(Sheet && in_that);
298 
302  Sheet & operator=(Sheet && in_that);
303 
304  virtual ~Sheet();
305 
306  static const HPS::Type staticType = HPS::Type::ExchangeSheet;
307  HPS::Type ObjectType() const { return staticType; }
308 
312  bool Equals(Sheet const & in_kit) const;
313 
314 #if !defined(_MSC_VER) || _MSC_VER >= 1900
315  Sheet & operator=(Sheet const & in_that) = default;
316 #endif
317 
321  bool operator==(Sheet const & in_kit) const;
322 
326  bool operator!=(Sheet const & in_kit) const;
327 
328  /* Activates this sheet */
329  HPS::View Activate();
330  };
331 
334  class EXCHANGE_API CADModel : public HPS::CADModel
335  {
336  public:
338  CADModel();
339 
343  CADModel(Component const & in_that);
344 
348  CADModel(HPS::CADModel const & in_that);
349 
352  CADModel(Exchange::CADModel const & in_that);
353 
356  CADModel(Exchange::CADModel && in_that);
357 
358  virtual ~CADModel();
359 
360  static const HPS::Type staticType = HPS::Type::ExchangeCADModel;
361  HPS::Type ObjectType() const { return staticType; }
362 
363 #if !defined(_MSC_VER) || _MSC_VER >= 1900
364  CADModel & operator=(Exchange::CADModel const & in_that) = default;
365 #endif
366 
370  CADModel & operator=(Exchange::CADModel && in_that);
371 
372 
375  A3DEntity * GetExchangeEntity() const;
376 
380  HPS::Component GetComponentFromEntity(A3DEntity * in_entity) const;
381 
387  bool GetEntityOwnership() const;
388 
389 
393  UTF8Array GetCurrentConfiguration() const;
394 
398  ConfigurationArray GetConfigurations() const;
399 
400  /* Gets a list of sheets for this CADModel (if any). Only formats which support the concept of sheets can return a non-empty array.
401  * \return The list of sheets for this CADModel */
402  SheetArray GetSheets() const;
403 
409  TranslationNotifier Translate(TranslationOptionsKit const & in_translation_options);
410 
415  ReloadNotifier Reload(TessellationOptionsKit const & in_options = TessellationOptionsKit(), TranslationOptionsKit const & in_translation_options = TranslationOptionsKit());
416 
422  void ShowAllPMI(Canvas const & in_canvas, size_t in_layer = 0);
423 
429  void SetAllPMIInFront(bool in_enable, Canvas const & in_canvas, size_t in_layer = 0);
430 
436  void HideAllPMI(Canvas const & in_canvas, size_t in_layer = 0);
437 
442  void Tessellate(TessellationOptionsKit const & in_options);
443 
450  bool ReplaceExchangeEntity(Component const & in_component, A3DEntity* in_a3d_entity);
451  };
452 
455  class EXCHANGE_API Capture : public HPS::Capture
456  {
457  public:
459  Capture();
460 
464  Capture(Component const & in_that);
465 
469  Capture(HPS::Capture const & in_that);
470 
473  Capture(Exchange::Capture const & in_that);
474 
477  Capture(Exchange::Capture && in_that);
478 
479  virtual ~Capture();
480 
481  static const HPS::Type staticType = HPS::Type::ExchangeCapture;
482  HPS::Type ObjectType() const { return staticType; }
483 
484 #if !defined(_MSC_VER) || _MSC_VER >= 1900
485  Capture & operator=(Exchange::Capture const & in_that) = default;
486 #endif
487 
491  Capture & operator=(Exchange::Capture && in_that);
492 
493 
496  A3DEntity * GetExchangeEntity() const;
497 
498  /* Activates this capture */
499  HPS::View Activate(HPS::ComponentPath const & in_capture_path = HPS::ComponentPath());
500  };
501 
504  class EXCHANGE_API Filter : public HPS::Filter
505  {
506  public:
508  Filter();
509 
513  Filter(Component const & in_that);
514 
518  Filter(HPS::Filter const & in_that);
519 
522  Filter(Exchange::Filter const & in_that);
523 
526  Filter(Exchange::Filter && in_that);
527 
528  virtual ~Filter();
529 
530  static const HPS::Type staticType = HPS::Type::ExchangeFilter;
531  HPS::Type ObjectType() const { return staticType; }
532 
533 #if !defined(_MSC_VER) || _MSC_VER >= 1900
534  Filter & operator=(Exchange::Filter const & in_that) = default;
535 #endif
536 
540  Filter & operator=(Exchange::Filter && in_that);
541 
542 
545  A3DEntity * GetExchangeEntity() const;
546  };
547 
549  class EXCHANGE_API Factory : public Sprocket
550  {
551  public:
556  static Component CreateComponent(HPS::Component const & in_owner, HPS::Component::ComponentType in_type, A3DEntity * in_entity = nullptr);
557 
563  static CADModel CreateCADModel(Model const & in_model = HPS::Factory::CreateModel(), A3DAsmModelFile * in_entity = nullptr, bool in_owns_entity = false);
564 
568  static Filter CreateFilter(HPS::Component const & in_owner, A3DEntity * in_entity = nullptr);
569 
576  static Capture CreateCapture(HPS::Component const & in_owner, A3DEntity * in_entity = nullptr, bool in_is_default = false);
577 
581  static Sheet CreateSheet(HPS::Component const & in_owner, A3DEntity * in_entity = nullptr);
582 
587  static Component DeInstanceComponent(HPS::ComponentPath const & in_component_path);
588 
589  private:
591  Factory();
592  };
593 
595  class EXCHANGE_API ImportNotifier : public IONotifier
596  {
597  public:
599  ImportNotifier();
600 
603  ImportNotifier(ImportNotifier const & in_that);
604 
609  ImportNotifier(IONotifier const & in_that);
610 
614  ImportNotifier(ImportNotifier && in_that);
615 
619  ImportNotifier & operator=(ImportNotifier && in_that);
620 
621  virtual ~ImportNotifier();
622 
623  static const HPS::Type staticType = HPS::Type::ExchangeImportNotifier;
624  HPS::Type ObjectType() const { return staticType; };
625 
629  ImportNotifier & operator=(ImportNotifier const & in_that);
630 
633  void Assign(ImportNotifier const & in_that);
634 
637  Exchange::CADModel GetCADModel() const;
638 
644  A3DRWParamsPrcReadHelper * GetPRCReadHelper() const;
645 
648  Time GetImportTime() const;
649 
652  Time GetParseTime() const;
653  };
654 
656  class EXCHANGE_API TranslationNotifier : public IONotifier
657  {
658  public:
660  TranslationNotifier();
661 
664  TranslationNotifier(TranslationNotifier const & in_that);
665 
670  TranslationNotifier(IONotifier const & in_that);
671 
675  TranslationNotifier(TranslationNotifier && in_that);
676 
680  TranslationNotifier & operator=(TranslationNotifier && in_that);
681 
682  virtual ~TranslationNotifier();
683 
684  static const HPS::Type staticType = HPS::Type::ExchangeTranslationNotifier;
685  HPS::Type ObjectType() const { return staticType; };
686 
690  TranslationNotifier & operator=(TranslationNotifier const & in_that);
691 
694  void Assign(TranslationNotifier const & in_that);
695 
698  Exchange::ParasolidEntityArray GetParasolidParts() const;
699 
702  HPS::Time GetImportTime() const;
703 
706  HPS::Time GetTranslationTime() const;
707  };
708 
710  class EXCHANGE_API ExportNotifier : public IONotifier
711  {
712  public:
714  ExportNotifier();
715 
718  ExportNotifier(ExportNotifier const & in_that);
719 
724  ExportNotifier(IONotifier const & in_that);
725 
729  ExportNotifier(ExportNotifier && in_that);
730 
734  ExportNotifier & operator=(ExportNotifier && in_that);
735 
736  virtual ~ExportNotifier();
737 
738  static const HPS::Type staticType = HPS::Type::ExchangeExportNotifier;
739  HPS::Type ObjectType() const { return staticType; };
740 
744  ExportNotifier & operator=(ExportNotifier const & in_that);
745 
748  void Assign(ExportNotifier const & in_that);
749 
753  A3DAsmModelFile * GetModelFile() const;
754  };
755 
757  class EXCHANGE_API ReloadNotifier : public IONotifier
758  {
759  public:
761  ReloadNotifier();
762 
765  ReloadNotifier(ReloadNotifier const & in_that);
766 
771  ReloadNotifier(IONotifier const & in_that);
772 
776  ReloadNotifier(ReloadNotifier && in_that);
777 
781  ReloadNotifier & operator=(ReloadNotifier && in_that);
782 
783  virtual ~ReloadNotifier();
784 
785  static const HPS::Type staticType = HPS::Type::ExchangeReloadNotifier;
786  HPS::Type ObjectType() const { return staticType; };
787 
791  ReloadNotifier & operator=(ReloadNotifier const & in_that);
792 
795  void Assign(ReloadNotifier const & in_that);
796  };
797 
798 
799  class ImportOptionsKit;
800  class ModelFileImportOptionsKit;
801 
802 #if TARGET_OS_ANDROID == 0 && TARGET_OS_IPHONE == 0
803  class Export3MFOptionsKit;
804  class ExportFBXOptionsKit;
805  class ExportACISOptionsKit;
806  class ExportJTOptionsKit;
807  class ExportPRCOptionsKit;
808  class ExportSTLOptionsKit;
809  class ExportOBJOptionsKit;
810  class ExportU3DOptionsKit;
811  class ExportXMLOptionsKit;
812  class ExportGLTFOptionsKit;
813 #endif
814 
815 #if !defined(TARGET_OS_ANDROID)
816  class ExportSTEPOptionsKit;
817  class ExportIGESOptionsKit;
818 #endif
819 
822  enum class BRepMode
823  {
826  TessellationOnly,
829  BRepOnly,
832  BRepAndTessellation,
833  };
834 
837  enum class ImportMode
838  {
841  Complete,
844  Incremental,
845  };
846 
849  enum class SurfaceType
850  {
851  Blend01,
852  Blend02,
853  Blend03,
854  Blend04,
855  NURBS,
856  Cone,
857  Cylinder,
858  Offset,
859  Pipe,
860  Plane,
861  Ruled,
862  Sphere,
863  Revolution,
864  Extrusion,
865  FromCurve,
866  Torus,
867  Transform,
868  };
869 
872  enum class CurveType
873  {
874  Blend,
875  NURBS,
876  Circle,
877  Composite,
878  CurveOnSurface,
879  Ellipse,
880  Equation,
881  Helix,
882  Hyperbola,
883  Intersection,
884  Line,
885  Offset,
886  Parabola,
887  Polyline,
888  Transform,
889  };
890 
891  typedef std::vector<SurfaceType, HPS::Allocator<SurfaceType> > SurfaceTypeArray;
892  typedef std::vector<CurveType, HPS::Allocator<CurveType> > CurveTypeArray;
893 
896  enum class AnnotationCaptureFitting
897  {
898  PMIOnly,
899  ModelAndPMI
900  };
901 
903  class EXCHANGE_API Tessellation
904  {
905  public:
908  enum class Type
909  {
910  Standard,
911  Custom
912  };
913 
914 
917  enum class Level
918  {
919  ExtraLow,
920  Low,
921  Medium,
922  High,
923  ExtraHigh,
924  };
925 
927  class EXCHANGE_API Chord
928  {
929  public:
932  enum class Limit
933  {
936  Ratio,
939  Height
940  };
941 
942  private:
944  Chord();
945  };
946 
949  enum class Accuracy
950  {
953  Standard,
956  Accurate,
958  GridAccurate
959  };
960 
961  private:
963  Tessellation();
964  };
965 
967  class EXCHANGE_API JT
968  {
969  public:
972  enum class Content
973  {
974  Geometry,
975  Tessellation,
976  GeometryAndTessellation
977  };
978 
981  enum class TessellationLevel
982  {
983  Low,
984  Medium,
985  High,
986  };
987 
990  enum class Version
991  {
992  JT81,
993  JT95,
994  JT100,
995  };
996 
997  private:
999  JT();
1000  };
1001 
1003  class EXCHANGE_API STEP
1004  {
1005  public:
1008  enum class Field
1009  {
1010  ProductName,
1011  NextAssemblyUsageOccurrenceID,
1012  NextAssemblyUsageOccurrenceName,
1013  NextAssemblyUsageOccurrenceDescription
1014  };
1015 
1018  enum class Format
1019  {
1020  AP203,
1021  AP214,
1022  AP242,
1023  };
1024 
1025  private:
1027  STEP();
1028  };
1029 
1031  class EXCHANGE_API PRC
1032  {
1033  public:
1036  enum class BRepCompression
1037  {
1038  None,
1039  Low,
1040  Medium,
1041  High
1042  };
1043 
1044  private:
1046  PRC();
1047  };
1048 
1050  class EXCHANGE_API ProE
1051  {
1052  public:
1055  enum class SessionColor
1056  {
1058  LastCreoVersion,
1060  ExchangeDefault,
1063  UserDefined
1064  };
1065 
1068  enum class FamilyTable
1069  {
1071  BRepOnly,
1073  BRepOrTessellation,
1075  BRepOrTessellationOrGeneric
1076  };
1077 
1080  enum class ConstructionEntities
1081  {
1083  On,
1085  Off,
1087  AsDatum,
1088  };
1089 
1090  private:
1092  ProE();
1093  };
1094 
1096  class EXCHANGE_API U3D
1097  {
1098  public:
1101  enum class Version
1102  {
1103  ECMA1,
1104  ECMA3
1105  };
1106 
1107  private:
1109  U3D();
1110  };
1111 
1113  class EXCHANGE_API Revit
1114  {
1115  public:
1116  enum class PhysicalProperties
1117  {
1119  NotComputed,
1121  Computed
1122  };
1123 
1124  private:
1126  Revit();
1127  };
1128 
1130  class EXCHANGE_API Configuration : public HPS::Sprocket
1131  {
1132  public:
1134  Configuration();
1135 
1138  Configuration(char const * in_name);
1139 
1144  Configuration(char const * in_name, size_t in_count, Configuration const in_subconfigurations[]);
1145 
1149  Configuration(char const * in_name, ConfigurationArray const & in_subconfigurations);
1150 
1153  Configuration(Configuration const & in_configuration);
1154 
1158  Configuration(Configuration && in_that);
1159 
1163  Configuration & operator=(Configuration && in_that);
1164 
1165  virtual ~Configuration();
1166 
1167  static const HPS::Type staticType = HPS::Type::ExchangeConfiguration;
1168  HPS::Type ObjectType() const { return staticType; }
1169 
1170 
1173  void Set(Configuration const & in_kit);
1174 
1177  void Show(Configuration & out_kit) const;
1178 
1182  Configuration & operator=(Configuration const & in_kit);
1183 
1186  bool Empty() const;
1187 
1191  bool Equals(Configuration const & in_kit) const;
1192 
1196  bool operator==(Configuration const & in_kit) const;
1197 
1201  bool operator!=(Configuration const & in_kit) const;
1202 
1203 
1206  HPS::UTF8 GetName() const;
1207 
1210  ConfigurationArray GetSubconfigurations() const;
1211  };
1212 
1214  class EXCHANGE_API File
1215  {
1216  public:
1219  enum class Format
1220  {
1221  Unsupported,
1222  ACIS,
1223  CADDS,
1224  CATIAV4,
1225  CATIAV5,
1226  CGR,
1227  COLLADA,
1228  CreoProE,
1229  DWG,
1230  DXF,
1231  IDEAS,
1232  IFC,
1233  IGES,
1234  Inventor,
1235  JT,
1236  KeyholeMarkupLanguage,
1237  LatticeXVL,
1238  OneSpaceDesigner,
1239  Parasolid,
1240  PDF,
1241  PRC,
1242  Rhino,
1243  NXUnigraphics,
1244  SolidEdge,
1245  SolidWorks,
1246  STEP,
1247  StereoLithography,
1248  ThreeDStudioMax,
1249  ThreeDXML,
1250  Universal3D,
1251  VDAFS,
1252  VRML,
1253  WavefrontObject,
1254  Revit,
1255  GLTF,
1256  DWF,
1257  FBX,
1258  STEPXML,
1259  };
1260 
1262  static Format GetFormat(char const * in_file_name);
1263 
1267  static ConfigurationArray GetConfigurations(char const * in_file_name);
1268 
1280  static void GetInformation(const char * in_file_name, Format & out_format, UTF8 & out_model_name, UTF8 & out_version, UTF8 & out_author, UTF8 & out_organization, UTF8 & out_time_stamp);
1281 
1287  static HPS::ImageKit GetThumbnailImage(const char * in_file_name);
1288 
1295  static ImportNotifier Import(char const * in_file_name, ImportOptionsKit const & in_options);
1296 
1303  static ImportNotifier Import(A3DAsmModelFile const * in_model_file, ModelFileImportOptionsKit const & in_options);
1304 
1312  static ImportNotifier Import(size_t in_byte_count, byte const in_prc_data[], ModelFileImportOptionsKit const & in_options);
1313 
1320  static ImportNotifier Import(ByteArray const & in_prc_data, ModelFileImportOptionsKit const & in_options);
1321 
1322 
1329  static TranslationNotifier Translate(char const * in_file_name, ImportOptionsKit const & in_options, TranslationOptionsKit const & in_translation_options);
1330 
1331 #if TARGET_OS_ANDROID == 0 && TARGET_OS_IPHONE == 0
1332 
1336  static ExportNotifier Export3MF(CADModel const & in_cad_model, char const * in_file_name, Export3MFOptionsKit const & in_options);
1337 
1343  static ExportNotifier Export3MF(KeyPathArray const & in_source, char const * in_file_name, Export3MFOptionsKit const & in_options);
1344 
1351  static ExportNotifier Export3MF(size_t in_count, KeyPath const in_source[], char const * in_file_name, Export3MFOptionsKit const & in_options);
1352 
1358  static ExportNotifier Export3MF(KeyPath in_source, char const * in_file_name, Export3MFOptionsKit const & in_options);
1359 
1364  static void ExportFBX(CADModel const & in_cad_model, char const * in_file_name, ExportFBXOptionsKit const & in_options);
1365 
1370  static void ExportACIS(CADModel const & in_cad_model, char const * in_file_name, ExportACISOptionsKit const & in_options);
1371 
1376  static void ExportJT(CADModel const & in_cad_model, char const * in_file_name, ExportJTOptionsKit const & in_options);
1377 
1383  static ExportNotifier ExportPRC(CADModel const & in_cad_model, char const * in_file_name, ExportPRCOptionsKit const & in_options);
1384 
1390  static ExportNotifier ExportPRC(KeyPathArray const & in_source, char const * in_file_name, bool in_compress_tessellation = false);
1391 
1398  static ExportNotifier ExportPRC(size_t in_count, KeyPath const in_source [], char const * in_file_name, bool in_compress_tessellation = false);
1399 
1406  static ExportNotifier ExportPRC(KeyPath const & in_source, char const * in_file_name, bool in_compress_tessellation = false);
1407 
1411  static ExportNotifier ExportPRC(KeyPathArray const & in_source);
1412 
1417  static ExportNotifier ExportPRC(size_t in_count, KeyPath const in_source []);
1418 
1422  static ExportNotifier ExportPRC(KeyPath const & in_source);
1423 
1428  static void ExportSTL(CADModel const & in_cad_model, char const * in_file_name, ExportSTLOptionsKit const & in_options);
1429 
1434  static void ExportOBJ(CADModel const & in_cad_model, char const * in_file_name, ExportOBJOptionsKit const & in_options);
1435 
1440  static void ExportU3D(CADModel const & in_cad_model, char const * in_file_name, ExportU3DOptionsKit const & in_options);
1441 
1445  static void ExportVRML(CADModel const & in_cad_model, char const * in_file_name);
1446 
1451  static void ExportXML(CADModel const & in_cad_model, char const * in_file_name, ExportXMLOptionsKit const & in_options);
1452 
1457  static void ExportGLTF(CADModel const & in_cad_model, char const * in_file_name, ExportGLTFOptionsKit const & in_options);
1458 
1459 #endif
1460 
1461 #if TARGET_OS_ANDROID == 0
1462 
1466  static void ExportIGES(CADModel const & in_cad_model, char const * in_file_name, ExportIGESOptionsKit const & in_options);
1467 
1472  static void ExportParasolid(CADModel const & in_cad_model, char const * in_file_name, ExportParasolidOptionsKit const & in_options);
1473 
1478  static void ExportSTEP(CADModel const & in_cad_model, char const * in_file_name, ExportSTEPOptionsKit const & in_options);
1479 #endif
1480 
1481  private:
1483  File();
1484  };
1485 
1487  class EXCHANGE_API NURBSConversionOptionsKit : public SprocketKit
1488  {
1489  public:
1491  NURBSConversionOptionsKit();
1492 
1495  NURBSConversionOptionsKit(NURBSConversionOptionsKit const & in_kit);
1496 
1500  NURBSConversionOptionsKit(NURBSConversionOptionsKit && in_that);
1501 
1505  NURBSConversionOptionsKit & operator=(NURBSConversionOptionsKit && in_that);
1506 
1507  virtual ~NURBSConversionOptionsKit();
1508 
1509  static const HPS::Type staticType = HPS::Type::ExchangeNURBSConversionOptionsKit;
1510  HPS::Type ObjectType() const { return staticType; }
1511 
1514  void Set(NURBSConversionOptionsKit const & in_kit);
1515 
1518  void Show(NURBSConversionOptionsKit & out_kit) const;
1519 
1523  NURBSConversionOptionsKit & operator=(NURBSConversionOptionsKit const & in_kit);
1524 
1527  bool Empty() const;
1528 
1532  bool Equals(NURBSConversionOptionsKit const & in_kit) const;
1533 
1537  bool operator==(NURBSConversionOptionsKit const & in_kit) const;
1538 
1542  bool operator!=(NURBSConversionOptionsKit const & in_kit) const;
1543 
1547  static NURBSConversionOptionsKit GetDefault();
1548 
1553  NURBSConversionOptionsKit & SetCrossSeamCurveReplacement(bool in_state);
1554 
1559  NURBSConversionOptionsKit & Set3DCurvesComputation(bool in_state);
1560 
1565  NURBSConversionOptionsKit & SetUVCurvesComputation(bool in_state, bool in_allow_cross_seam_curves);
1566 
1571  NURBSConversionOptionsKit & SetClosedFaceSplitting(bool in_state);
1572 
1577  NURBSConversionOptionsKit & SetPeriodicFaceSplitting(bool in_state);
1578 
1583  NURBSConversionOptionsKit & SetParameterization(bool in_state);
1584 
1589  NURBSConversionOptionsKit & SetTolerance(double in_tolerance);
1590 
1596  NURBSConversionOptionsKit & SetAllowedSurfaces(SurfaceTypeArray const & in_allowed_surfaces);
1597 
1604  NURBSConversionOptionsKit & SetAllowedSurfaces(size_t in_count, SurfaceType const in_allowed_surfaces []);
1605 
1611  NURBSConversionOptionsKit & SetAllowedCurves(CurveTypeArray const & in_allowed_curves);
1612 
1619  NURBSConversionOptionsKit & SetAllowedCurves(size_t in_count, CurveType const in_allowed_curves []);
1620 
1621 
1624  NURBSConversionOptionsKit & UnsetCrossSeamCurveReplacement();
1625 
1628  NURBSConversionOptionsKit & Unset3DCurvesComputation();
1629 
1632  NURBSConversionOptionsKit & UnsetUVCurvesComputation();
1633 
1636  NURBSConversionOptionsKit & UnsetClosedFaceSplitting();
1637 
1640  NURBSConversionOptionsKit & UnsetPeriodicFaceSplitting();
1641 
1644  NURBSConversionOptionsKit & UnsetParameterization();
1645 
1648  NURBSConversionOptionsKit & UnsetTolerance();
1649 
1652  NURBSConversionOptionsKit & UnsetAllowedSurfaces();
1653 
1656  NURBSConversionOptionsKit & UnsetAllowedCurves();
1657 
1660  NURBSConversionOptionsKit & UnsetEverything();
1661 
1662 
1663 
1667  bool ShowCrossSeamCurveReplacement(bool & out_state) const;
1668 
1672  bool Show3DCurvesComputation(bool & out_state) const;
1673 
1678  bool ShowUVCurvesComputation(bool & out_state, bool & out_allow_cross_seam_curves) const;
1679 
1683  bool ShowClosedFaceSplitting(bool & out_state) const;
1684 
1688  bool ShowPeriodicFaceSplitting(bool & out_state) const;
1689 
1693  bool ShowParameterization(bool & out_state) const;
1694 
1698  bool ShowTolerance(double & out_tolerance) const;
1699 
1703  bool ShowAllowedSurfaces(SurfaceTypeArray & out_allowed_surfaces) const;
1704 
1708  bool ShowAllowedCurves(CurveTypeArray & out_allowed_curves) const;
1709  };
1710 
1712  class EXCHANGE_API ImportOptionsKit : public SprocketKit
1713  {
1714  public:
1716  ImportOptionsKit();
1717 
1720  ImportOptionsKit(ImportOptionsKit const & in_kit);
1721 
1725  ImportOptionsKit(ImportOptionsKit && in_that);
1726 
1730  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
1731 
1732  virtual ~ImportOptionsKit();
1733 
1734  static const HPS::Type staticType = HPS::Type::ExchangeImportOptionsKit;
1735  HPS::Type ObjectType() const { return staticType; }
1736 
1740  static ImportOptionsKit GetDefault();
1741 
1744  void Set(ImportOptionsKit const & in_kit);
1745 
1748  void Show(ImportOptionsKit & out_kit) const;
1749 
1753  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
1754 
1757  bool Empty() const;
1758 
1762  bool Equals(ImportOptionsKit const & in_kit) const;
1763 
1767  bool operator==(ImportOptionsKit const & in_kit) const;
1768 
1772  bool operator!=(ImportOptionsKit const & in_kit) const;
1773 
1774 
1780  ImportOptionsKit & SetBRepMode(BRepMode in_mode);
1781 
1787  ImportOptionsKit & SetSolids(bool in_state);
1788 
1794  ImportOptionsKit & SetSurfaces(bool in_state);
1795 
1801  ImportOptionsKit & SetWireframes(bool in_state);
1802 
1808  ImportOptionsKit & SetPMI(bool in_state);
1809 
1816  ImportOptionsKit & SetAttributes(bool in_state);
1817 
1823  ImportOptionsKit & SetHiddenObjects(bool in_state);
1824 
1830  ImportOptionsKit & SetConstructionAndReferences(bool in_state);
1831 
1837  ImportOptionsKit & SetActiveFilter(bool in_state);
1838 
1846  ImportOptionsKit & SetFeatureTrees(bool in_state);
1847 
1853  ImportOptionsKit & SetDrawings(bool in_state);
1854 
1860  ImportOptionsKit & SetDefaultUnits(Units in_units);
1861 
1867  ImportOptionsKit & SetMultiProcessCount(unsigned int in_count);
1868 
1874  ImportOptionsKit & SetSewingTolerance(double in_tolerance);
1875 
1882  ImportOptionsKit & SetComputePreferredOpenShellOrientation(bool in_state);
1883 
1890  ImportOptionsKit & SetPMISubstitutionFont(char const * in_font_name, bool in_always_substitute = false);
1891 
1897  ImportOptionsKit & SetPMIPrecision(size_t in_precision);
1898 
1904  ImportOptionsKit & SetPMIDefaultUnits(Units in_units);
1905 
1913  ImportOptionsKit & SetPMIFlipping(bool in_flip);
1914 
1921  ImportOptionsKit & SetRemovedViews(bool read_removed_views);
1922 
1930  ImportOptionsKit & SetExternalProductOccurrence(bool read_external_po);
1931 
1939  ImportOptionsKit & SetPMIDefaultColor(RGBColor const & in_color, bool in_override_color = false);
1940 
1946  ImportOptionsKit & SetTessellationCleanup(bool in_cleanup);
1947 
1953  ImportOptionsKit & SetTessellationLevel(Tessellation::Level in_level);
1954 
1961  ImportOptionsKit & SetTessellationLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
1962 
1974  ImportOptionsKit & SetTessellationAccuracy(Tessellation::Accuracy in_type, bool in_accurate_normals = true, bool in_accurate_surface_curvatures = false, double in_accurate_grid_maximum_stitch_length = 0.0);
1975 
1981  ImportOptionsKit & SetTessellationPreservesUVPoints(bool in_state);
1982 
1988  ImportOptionsKit & SetTessellationMaximumEdgeLength(double in_length);
1989 
1995  ImportOptionsKit & SetTextureDirectories(size_t in_count, UTF8 const in_directories[]);
1996 
2001  ImportOptionsKit & SetTextureDirectories(UTF8Array const & in_directories);
2002 
2009  ImportOptionsKit & SetSearchDirectories(size_t in_count, UTF8 const in_directories[], bool const in_recurse_flags[]);
2010 
2016  ImportOptionsKit & SetSearchDirectories(UTF8Array const & in_directories, BoolArray const & in_recurse_flags);
2017 
2026  ImportOptionsKit & SetSearchDirectories(size_t in_count, UTF8 const in_directories[], UTF8 const in_logical_names[], bool const in_recurse_flags[]);
2027 
2036  ImportOptionsKit & SetSearchDirectories(UTF8Array const & in_directories, UTF8Array const & in_logical_names, BoolArray const & in_recurse_flags);
2037 
2043  ImportOptionsKit & SetSearchDirectoriesByFile(size_t in_count, UTF8 const in_file_names[]);
2044 
2049  ImportOptionsKit & SetSearchDirectoriesByFile(UTF8Array const & in_file_names);
2050 
2057  ImportOptionsKit & SetSearchRootDirectory(bool in_state, bool in_recursive = true);
2058 
2063  ImportOptionsKit & SetConfiguration(char const * in_configuration);
2064 
2070  ImportOptionsKit & SetConfiguration(size_t in_count, UTF8 const in_configuration[]);
2071 
2076  ImportOptionsKit & SetConfiguration(UTF8Array const & in_configuration);
2077 
2083  ImportOptionsKit & SetCatiaV4LogicalNameForRootDirectory(char const * in_name);
2084 
2091  ImportOptionsKit & SetCatiaV4LogicalNameSearching(bool in_state);
2092 
2099  ImportOptionsKit & SetCatiaV5Cache(bool in_active, char const * in_path);
2100 
2106  ImportOptionsKit & SetCatiaV5MaterialRendering(bool in_active);
2107 
2115  ImportOptionsKit & SetUnigraphicsPreferredReferenceSets(size_t in_count, UTF8 const in_reference_sets[], bool in_apply_to_all_levels);
2116 
2123  ImportOptionsKit & SetUnigraphicsPreferredReferenceSets(UTF8Array const & in_reference_sets, bool in_apply_to_all_levels);
2124 
2130  ImportOptionsKit & SetUnigraphicsFittedCamera(bool in_state);
2131 
2137  ImportOptionsKit & SetProECodePageName(char const * in_name);
2138 
2144  ImportOptionsKit & SetProEDimensionTolerance(bool in_state);
2145 
2151  ImportOptionsKit & SetProESubpartPMI(bool in_state);
2152 
2158  ImportOptionsKit & SetProESessionColor(ProE::SessionColor in_type);
2159 
2166  ImportOptionsKit & SetProEMissingBoolean(bool in_state);
2167 
2174  ImportOptionsKit & SetProEMissingFlexibleComponent(bool in_state);
2175 
2182  ImportOptionsKit & SetProEFamilyTableSource(ProE::FamilyTable in_source);
2183 
2190  ImportOptionsKit & SetProEHomeView(bool in_state);
2191 
2198  ImportOptionsKit & SetProEExplodedViews(bool in_state);
2199 
2206  ImportOptionsKit & SetProEDatum(bool in_state);
2207 
2208 
2215  ImportOptionsKit & SetProEConstructionEntities(ProE::ConstructionEntities in_state);
2216 
2223  ImportOptionsKit & SetProESkeletons(bool in_state);
2224 
2231  ImportOptionsKit & SetSTEPNamePreference(STEP::Field in_field);
2232 
2238  ImportOptionsKit & SetSTEPCodePageName(char const * in_name);
2239 
2245  ImportOptionsKit & SetSTEPFirstColorPreference(bool in_state);
2246 
2252  ImportOptionsKit & SetSTEPShellBasedSurfaceModelSplitting(bool in_state);
2253 
2259  ImportOptionsKit & SetSTEPOrientationHealing(bool in_state);
2260 
2266  ImportOptionsKit & SetSTEPValidationProperties(bool in_state);
2267 
2273  ImportOptionsKit & SetIFCCodePageName(char const * in_name);
2274 
2281  ImportOptionsKit & SetIFCAttributeXMLFile(char const * in_filename);
2282 
2288  ImportOptionsKit & SetIFCOwnerHistoryOptimization(bool in_state);
2289 
2295  ImportOptionsKit & SetIFCFaceOptimization(bool in_state);
2296 
2303  ImportOptionsKit & SetIFCEdges(bool in_state);
2304 
2310  ImportOptionsKit & SetIFCMetadata(bool in_state);
2311 
2317  ImportOptionsKit & SetPDF3DStreamIndex(size_t in_index);
2318 
2324  ImportOptionsKit & SetJTTessellationLevel(JT::TessellationLevel in_jt_tessellation_level);
2325 
2331  ImportOptionsKit& SetSolidworksDisplayVisibleDatum(bool in_state);
2332 
2338  ImportOptionsKit & SetInventorEmbeddedTessellation(bool in_state);
2339 
2345  ImportOptionsKit & SetPRCReadHelper(bool in_use_helper);
2346 
2353  ImportOptionsKit & SetRhinoForceRenderedModeColors(bool in_state);
2354 
2361  ImportOptionsKit & SetRevitPhysicalProperties(Revit::PhysicalProperties in_physical_properties);
2362 
2366  ImportOptionsKit & SetAnnotationCaptureFitting(AnnotationCaptureFitting in_fitting);
2367 
2379  ImportOptionsKit & SetLocation(ComponentPath const & in_path, MatrixKit const & in_transform = MatrixKit());
2380 
2392  ImportOptionsKit & SetMode(ImportMode in_mode);
2393 
2403  ImportOptionsKit & SetIncrementalComponentPath(HPS::ComponentPath const & in_path);
2404 
2412  ImportOptionsKit & SetIncrementalComponentPaths(size_t in_count, HPS::ComponentPath const in_paths[]);
2413 
2420  ImportOptionsKit & SetIncrementalComponentPaths(HPS::ComponentPathArray const & in_paths);
2421 
2425  ImportOptionsKit & SetNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit const & in_nurbs_conversion_options);
2426 
2431  ImportOptionsKit & SetGeometryDefaultColor(RGBAColor const & in_color);
2432 
2433  /* When this option is enabled, translations that are deemed to be especially large compared to the model size are removed from the
2434  * scene graph and instead imported as user data, at the index specified, on the segment where the translation would have been.
2435  * Removing very large translation is useful to avoid visual artifacts due to loss in precision.
2436  * Note that only part of a translation might be extracted.
2437  * If you are adding a model to an existing scene through the SetLocation feature, and the original model was loaded using the
2438  * SetLargeTranslationExtraction setting, the same data_index value should be used for the model being added to the existing scene,
2439  * so that any translations previously extracted from the model can be taken into account during import.
2440  * \param in_state Whether to enable large translation extraction
2441  * \param in_data_index The index at which the user data representing the extracted translation will be stored
2442  * \return A reference to this ImportOptionsKit. */
2443  ImportOptionsKit & SetLargeTranslationExtraction(bool in_state, intptr_t in_data_index = 1);
2444 
2447  ImportOptionsKit & UnsetBRepMode();
2448 
2451  ImportOptionsKit & UnsetSolids();
2452 
2455  ImportOptionsKit & UnsetSurfaces();
2456 
2459  ImportOptionsKit & UnsetWireframes();
2460 
2463  ImportOptionsKit & UnsetPMI();
2464 
2467  ImportOptionsKit & UnsetAttributes();
2468 
2471  ImportOptionsKit & UnsetHiddenObjects();
2472 
2475  ImportOptionsKit & UnsetConstructionAndReferences();
2476 
2479  ImportOptionsKit & UnsetActiveFilter();
2480 
2483  ImportOptionsKit & UnsetDrawings();
2484 
2487  ImportOptionsKit & UnsetFeatureTrees();
2488 
2491  ImportOptionsKit & UnsetSewingTolerance();
2492 
2495  ImportOptionsKit & UnsetComputePreferredOpenShellOrientation();
2496 
2499  ImportOptionsKit & UnsetDefaultUnits();
2500 
2503  ImportOptionsKit & UnsetMultiProcessCount();
2504 
2507  ImportOptionsKit & UnsetPMISubstitutionFont();
2508 
2511  ImportOptionsKit & UnsetPMIPrecision();
2512 
2515  ImportOptionsKit & UnsetPMIDefaultUnits();
2516 
2519  ImportOptionsKit & UnsetPMIDefaultColor();
2520 
2523  ImportOptionsKit & UnsetTessellationLevel();
2524 
2527  ImportOptionsKit & UnsetTessellationAccuracy();
2528 
2531  ImportOptionsKit & UnsetTessellationCleanup();
2532 
2535  ImportOptionsKit & UnsetPMIFlipping();
2536 
2539  ImportOptionsKit & UnsetRemovedViews();
2540 
2543  ImportOptionsKit & UnsetExternalProductOccurrence();
2544 
2547  ImportOptionsKit & UnsetTessellationPreservesUVPoints();
2548 
2551  ImportOptionsKit & UnsetTessellationMaximumEdgeLength();
2552 
2555  ImportOptionsKit & UnsetTextureDirectories();
2556 
2559  ImportOptionsKit & UnsetSearchDirectories();
2560 
2563  ImportOptionsKit & UnsetSearchDirectoriesByFile();
2564 
2567  ImportOptionsKit & UnsetSearchRootDirectory();
2568 
2571  ImportOptionsKit & UnsetConfiguration();
2572 
2575  ImportOptionsKit & UnsetCatiaV4LogicalNameForRootDirectory();
2576 
2579  ImportOptionsKit & UnsetCatiaV4LogicalNameSearching();
2580 
2583  ImportOptionsKit & UnsetCatiaV5Cache();
2584 
2587  ImportOptionsKit & UnsetCatiaV5MaterialRendering();
2588 
2591  ImportOptionsKit & UnsetUnigraphicsPreferredReferenceSets();
2592 
2595  ImportOptionsKit & UnsetUnigraphicsFittedCamera();
2596 
2599  ImportOptionsKit & UnsetProECodePageName();
2600 
2603  ImportOptionsKit & UnsetProEDimensionTolerance();
2604 
2607  ImportOptionsKit & UnsetProESubpartPMI();
2608 
2611  ImportOptionsKit & UnsetProESessionColor();
2612 
2615  ImportOptionsKit & UnsetProEDatum();
2616 
2619  ImportOptionsKit & UnsetProEHomeView();
2620 
2623  ImportOptionsKit & UnsetProEExplodedViews();
2624 
2627  ImportOptionsKit & UnsetProEMissingBoolean();
2628 
2631  ImportOptionsKit & UnsetProEMissingFlexibleComponent();
2632 
2635  ImportOptionsKit & UnsetProEFamilyTreeSource();
2636 
2639  ImportOptionsKit & UnsetProEConstructionEntities();
2640 
2643  ImportOptionsKit & UnsetProESkeletons();
2644 
2647  ImportOptionsKit & UnsetSTEPNamePreference();
2648 
2651  ImportOptionsKit & UnsetSTEPFirstColorPreference();
2652 
2655  ImportOptionsKit & UnsetSTEPCodePageName();
2656 
2659  ImportOptionsKit & UnsetSTEPShellBasedSurfaceModelSplitting();
2660 
2663  ImportOptionsKit & UnsetSTEPOrientationHealing();
2664 
2667  ImportOptionsKit & UnsetSTEPValidationProperties();
2668 
2671  ImportOptionsKit & UnsetIFCCodePageName();
2672 
2675  ImportOptionsKit & UnsetIFCAttributeXMLFile();
2676 
2679  ImportOptionsKit & UnsetIFCOwnerHistoryOptimization();
2680 
2683  ImportOptionsKit & UnsetIFCFaceOptimization();
2684 
2687  ImportOptionsKit & UnsetIFCEdges();
2688 
2691  ImportOptionsKit & UnsetIFCMetadata();
2692 
2695  ImportOptionsKit & UnsetPDF3DStreamIndex();
2696 
2699  ImportOptionsKit & UnsetJTTessellationLevel();
2700 
2703  ImportOptionsKit& UnsetSolidworksDisplayVisibleDatum();
2704 
2707  ImportOptionsKit & UnsetInventorEmbeddedTessellation();
2708 
2711  ImportOptionsKit & UnsetPRCReadHelper();
2712 
2715  ImportOptionsKit & UnsetRhinoForceRenderedModeColors();
2716 
2719  ImportOptionsKit & UnsetRevitPhysicalProperties();
2720 
2723  ImportOptionsKit & UnsetAnnotationCaptureFitting();
2724 
2727  ImportOptionsKit & UnsetLocation();
2728 
2731  ImportOptionsKit & UnsetMode();
2732 
2735  ImportOptionsKit & UnsetIncrementalComponentPaths();
2736 
2739  ImportOptionsKit & UnsetNURBSConversion();
2740 
2743  ImportOptionsKit & UnsetGeometryDefaultColor();
2744 
2745  /* Removes the large translation extraction setting.
2746  * \return A reference to this ImportOptionsKit. */
2747  ImportOptionsKit & UnsetLargeTranslationExtraction();
2748 
2751  ImportOptionsKit & UnsetEverything();
2752 
2756  bool ShowBRepMode(BRepMode & out_mode) const;
2757 
2761  bool ShowSolids(bool & out_state) const;
2762 
2766  bool ShowSurfaces(bool & out_state) const;
2767 
2771  bool ShowWireframes(bool & out_state) const;
2772 
2776  bool ShowPMI(bool & out_state) const;
2777 
2781  bool ShowAttributes(bool & out_state) const;
2782 
2786  bool ShowHiddenObjects(bool & out_state) const;
2787 
2791  bool ShowConstructionAndReferences(bool & out_state) const;
2792 
2796  bool ShowActiveFilter(bool & out_state) const;
2797 
2801  bool ShowDrawings(bool & out_state) const;
2802 
2806  bool ShowFeatureTrees(bool & out_state) const;
2807 
2811  bool ShowSewingTolerance(double & out_tolerance) const;
2812 
2816  bool ShowComputePreferredOpenShellOrientation(bool & out_state) const;
2817 
2821  bool ShowDefaultUnits(Units & out_units) const;
2822 
2826  bool ShowMultiProcessCount(unsigned int & out_count) const;
2827 
2832  bool ShowPMISubstitutionFont(UTF8 & out_font_name, bool & out_always_substitute) const;
2833 
2837  bool ShowPMIPrecision(size_t & out_precision) const;
2838 
2842  bool ShowPMIDefaultUnits(Units & out_units) const;
2843 
2848  bool ShowPMIDefaultColor(RGBColor & out_color, bool & out_override) const;
2849 
2857  bool ShowTessellationLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
2858 
2865  bool ShowTessellationAccuracy(Tessellation::Accuracy & out_type, bool & out_accurate_normals, bool & out_accurate_surface_curvatures, double & out_accurate_grid_maximum_stitch_length) const;
2866 
2870  bool ShowTessellationCleanup(bool & out_cleanup) const;
2871 
2875  bool ShowPMIFlipping(bool & out_pmi_flipping) const;
2876 
2880  bool ShowRemovedViews(bool & out_read_removed_views) const;
2881 
2885  bool ShowExternalProductOccurrence(bool & out_read_external_po) const;
2886 
2890  bool ShowTessellationPreservesUVPoints(bool & out_state) const;
2891 
2895  bool ShowTessellationMaximumEdgeLength(double & out_length) const;
2896 
2900  bool ShowTextureDirectories(UTF8Array & out_directories) const;
2901 
2907  bool ShowSearchDirectories(UTF8Array & out_directories, UTF8Array & out_logical_names, BoolArray & out_recurse_flags) const;
2908 
2912  bool ShowSearchDirectoriesByFile(UTF8Array & out_file_names) const;
2913 
2918  bool ShowSearchRootDirectory(bool & out_state, bool & out_recursive) const;
2919 
2923  bool ShowConfiguration(UTF8Array & out_configuration) const;
2924 
2928  bool ShowCatiaV4LogicalNameForRootDirectory(UTF8 & out_name) const;
2929 
2933  bool ShowCatiaV4LogicalNameSearching(bool & out_state) const;
2934 
2939  bool ShowCatiaV5Cache(bool & out_active, UTF8 & out_path) const;
2940 
2944  bool ShowCatiaV5MaterialRendering(bool & out_active) const;
2945 
2950  bool ShowUnigraphicsPreferredReferenceSets(UTF8Array & out_reference_sets, bool & out_apply_to_all_levels) const;
2951 
2955  bool ShowUnigraphicsFittedCamera(bool & out_state) const;
2956 
2960  bool ShowProECodePageName(UTF8 & out_name) const;
2961 
2965  bool ShowProEDimensionTolerance(bool & out_state) const;
2966 
2970  bool ShowProESubpartPMI(bool & out_state) const;
2971 
2975  bool ShowProESessionColor(ProE::SessionColor & out_type) const;
2976 
2980  bool ShowProEDatum(bool & out_state) const;
2981 
2985  bool ShowProEHomeView(bool & out_state) const;
2986 
2990  bool ShowProEExplodedViews(bool & out_state) const;
2991 
2995  bool ShowProEMissingBoolean(bool & out_state) const;
2996 
3000  bool ShowProEMissingFlexibleComponent(bool & out_state) const;
3001 
3005  bool ShowProEFamilyTableSource(ProE::FamilyTable & out_source) const;
3006 
3010  bool ShowProEConstructionEntities(ProE::ConstructionEntities & out_state) const;
3011 
3015  bool ShowProESkeletons(bool & out_state) const;
3016 
3020  bool ShowSTEPNamePreference(STEP::Field & out_field) const;
3021 
3025  bool ShowSTEPFirstColorPreference(bool & out_state) const;
3026 
3030  bool ShowSTEPCodePageName(UTF8 & out_name) const;
3031 
3035  bool ShowSTEPShellBasedSurfaceModelSplitting(bool & out_state) const;
3036 
3040  bool ShowSTEPOrientationHealing(bool & out_state) const;
3041 
3045  bool ShowSTEPValidationProperties(bool & out_state) const;
3046 
3050  bool ShowIFCCodePageName(UTF8 & out_name) const;
3051 
3055  bool ShowIFCAttributeXMLFile(UTF8 & out_filename) const;
3056 
3060  bool ShowIFCOwnerHistoryOptimization(bool & out_state) const;
3061 
3065  bool ShowIFCFaceOptimization(bool & out_state) const;
3066 
3070  bool ShowIFCEdges(bool & out_state) const;
3071 
3075  bool ShowIFCMetadata(bool & out_state) const;
3076 
3080  bool ShowPDF3DStreamIndex(size_t & out_index) const;
3081 
3085  bool ShowJTTessellationLevel(JT::TessellationLevel & out_tessellation_level) const;
3086 
3090  bool ShowSolidworksDisplayVisibleDatum(bool& out_state) const;
3091 
3095  bool ShowInventorEmbeddedTessellation(bool & out_state) const;
3096 
3100  bool ShowPRCReadHelper(bool & out_use_helper) const;
3101 
3105  bool ShowRhinoForceRenderedModeColors(bool & out_state) const;
3106 
3110  bool ShowRevitPhysicalProperties(Revit::PhysicalProperties & out_physical_properties) const;
3111 
3115  bool ShowAnnotationCaptureFitting(AnnotationCaptureFitting & out_fitting) const;
3116 
3121  bool ShowLocation(ComponentPath & out_path, MatrixKit & out_transform) const;
3122 
3126  bool ShowMode(ImportMode & out_mode) const;
3127 
3131  bool ShowIncrementalComponentPaths(HPS::ComponentPathArray & out_paths) const;
3132 
3136  bool ShowNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit & out_nurbs_conversion_options) const;
3137 
3141  bool ShowGeometryDefaultColor(RGBAColor & out_color) const;
3142 
3143  /* Shows the large translation extraction setting.
3144  * \param out_state Whether to extract large translations during an import.
3145  * \param out_data_index The index at which the user data representing the extracted translation will be stored
3146  * \return <span class='code'>true</span> if a large translation extraction setting was specified, <span class='code'>false</span> otherwise. */
3147  bool ShowLargeTranslationExtraction(bool & out_state, intptr_t & out_data_index) const;
3148  };
3149 
3151  class EXCHANGE_API Translation
3152  {
3153  public:
3156  enum class Healing
3157  {
3158  Off,
3159  On,
3160  OnlyIfNotParasolid,
3161  };
3162 
3165  enum class AccurateEdges
3166  {
3167  Off,
3168  On,
3169  OnlyIfNotParasolid,
3170  };
3171 
3174  enum class Simplification
3175  {
3176  Off,
3177  On,
3178  OnlyIfNotParasolid,
3179  };
3180 
3183  enum class Merging
3184  {
3185  Off,
3186  On,
3187  OnlyIfNotParasolid,
3188  };
3189 
3190  private:
3192  Translation();
3193  };
3194 
3196  class EXCHANGE_API TranslationOptionsKit : public SprocketKit
3197  {
3198  public:
3200  TranslationOptionsKit();
3201 
3204  TranslationOptionsKit(TranslationOptionsKit const & in_kit);
3205 
3209  TranslationOptionsKit(TranslationOptionsKit && in_that);
3210 
3214  TranslationOptionsKit & operator=(TranslationOptionsKit && in_that);
3215 
3216  virtual ~TranslationOptionsKit();
3217 
3218  static const HPS::Type staticType = HPS::Type::ExchangeTranslationOptionsKit;
3219  HPS::Type ObjectType() const { return staticType; }
3220 
3224  static TranslationOptionsKit GetDefault();
3225 
3228  void Set(TranslationOptionsKit const & in_kit);
3229 
3232  void Show(TranslationOptionsKit & out_kit) const;
3233 
3237  TranslationOptionsKit & operator=(TranslationOptionsKit const & in_kit);
3238 
3241  bool Empty() const;
3242 
3246  bool Equals(TranslationOptionsKit const & in_kit) const;
3247 
3251  bool operator==(TranslationOptionsKit const & in_kit) const;
3252 
3256  bool operator!=(TranslationOptionsKit const & in_kit) const;
3257 
3263  TranslationOptionsKit & SetSolidsAsFaces(bool in_state);
3264 
3270  TranslationOptionsKit & SetTessellation(bool in_state);
3271 
3277  TranslationOptionsKit & SetHiddenObjects(bool in_state);
3278 
3282  TranslationOptionsKit & SetApplication(char const * in_name);
3283 
3287  TranslationOptionsKit & SetVersion(char const * in_version);
3288 
3294  TranslationOptionsKit& SetExplodeMultiBodies(bool in_state);
3295 
3299  TranslationOptionsKit & SetHealing(Translation::Healing in_healing);
3300 
3304  TranslationOptionsKit & SetAccurateEdges(Translation::AccurateEdges in_accurate_edges);
3305 
3309  TranslationOptionsKit & SetSimplification(Translation::Simplification in_simplification);
3310 
3314  TranslationOptionsKit & SetEntityMerging(Translation::Merging in_merging);
3315 
3320  TranslationOptionsKit & SetSewing(bool in_state, double in_tolerance = 0.0);
3321 
3325  TranslationOptionsKit & SetDisjointFaces(bool in_state);
3326 
3329  TranslationOptionsKit & UnsetSolidsAsFaces();
3330 
3333  TranslationOptionsKit & UnsetTessellation();
3334 
3337  TranslationOptionsKit & UnsetHiddenObjects();
3338 
3341  TranslationOptionsKit & UnsetApplication();
3342 
3345  TranslationOptionsKit & UnsetVersion();
3346 
3349  TranslationOptionsKit & UnsetHealing();
3350 
3353  TranslationOptionsKit & UnsetAccurateEdges();
3354 
3357  TranslationOptionsKit & UnsetSimplification();
3358 
3361  TranslationOptionsKit & UnsetEntityMerging();
3362 
3365  TranslationOptionsKit & UnsetSewing();
3366 
3369  TranslationOptionsKit & UnsetDisjointFaces();
3370 
3373  TranslationOptionsKit& UnsetExplodeMultiBodies();
3374 
3377  TranslationOptionsKit & UnsetEverything();
3378 
3379 
3383  bool ShowSolidsAsFaces(bool & out_state) const;
3384 
3388  bool ShowTessellation(bool & out_state) const;
3389 
3393  bool ShowHiddenObjects(bool & out_state) const;
3394 
3398  bool ShowApplication(UTF8 & out_name) const;
3399 
3403  bool ShowVersion(UTF8 & out_version) const;
3404 
3408  bool ShowExplodeMultiBodies(bool& out_state) const;
3409 
3413  bool ShowHealing(Translation::Healing & out_healing) const;
3414 
3418  bool ShowAccurateEdges(Translation::AccurateEdges & out_accurate_edges) const;
3419 
3423  bool ShowSimplification(Translation::Simplification & out_simplification) const;
3424 
3428  bool ShowEntityMerging(Translation::Merging & out_merging) const;
3429 
3434  bool ShowSewing(bool & out_state, double & out_tolerance) const;
3435 
3439  bool ShowDisjointFaces(bool & out_state) const;
3440 
3445  TranslationOptionsKit & SetMultiProcessCount(unsigned int in_count);
3446 
3449  TranslationOptionsKit & UnsetMultiProcessCount();
3450 
3454  bool ShowMultiProcessCount(unsigned int & out_count) const;
3455  };
3456 
3457 
3458 
3463  class EXCHANGE_API ModelFileImportOptionsKit : public SprocketKit
3464  {
3465  public:
3467  ModelFileImportOptionsKit();
3468 
3471  ModelFileImportOptionsKit(ModelFileImportOptionsKit const & in_kit);
3472 
3476  ModelFileImportOptionsKit(ModelFileImportOptionsKit && in_that);
3477 
3481  ModelFileImportOptionsKit & operator=(ModelFileImportOptionsKit && in_that);
3482 
3483  virtual ~ModelFileImportOptionsKit();
3484 
3485  static const HPS::Type staticType = HPS::Type::ExchangeModelFileImportOptionsKit;
3486  HPS::Type ObjectType() const { return staticType; }
3487 
3491  static ModelFileImportOptionsKit GetDefault();
3492 
3495  void Set(ModelFileImportOptionsKit const & in_kit);
3496 
3499  void Show(ModelFileImportOptionsKit & out_kit) const;
3500 
3504  ModelFileImportOptionsKit & operator=(ModelFileImportOptionsKit const & in_kit);
3505 
3508  bool Empty() const;
3509 
3513  bool Equals(ModelFileImportOptionsKit const & in_kit) const;
3514 
3518  bool operator==(ModelFileImportOptionsKit const & in_kit) const;
3519 
3523  bool operator!=(ModelFileImportOptionsKit const & in_kit) const;
3524 
3525 
3526  /* Dictates whether Visualize will flip pmi when rotating so that text / symbols remain readable.
3527  * \note If exchange reports that a markup does not contain leader lines, but the tessellation does contain lines that markup will not be
3528  * flipped. This is a precaution for models where the leader line geometry was included as part of the markup tessellation and
3529  * flipping the geometry would cause any present leader lines to point in the wrong direction.
3530  * \param in_cleanup Whether or not to have visualize flip pmi when rotating.
3531  * \return A reference to this ModelFileImportOptionsKit.
3532  */
3533  ModelFileImportOptionsKit & SetPMIFlipping(bool in_flip);
3534 
3540  ModelFileImportOptionsKit & SetTessellationLevel(Tessellation::Level in_level);
3541 
3548  ModelFileImportOptionsKit & SetTessellationLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
3549 
3561  ModelFileImportOptionsKit & SetTessellationAccuracy(Tessellation::Accuracy in_type, bool in_accurate_normals = true, bool in_accurate_surface_curvatures = false, double accurate_grid_maximum_stitch_length = 0.0);
3562 
3563  /* Dictates whether Exchange tesselation data will be released from their parent representation items during import.
3564  * \warning Setting this option to true will cause future exports to output without tessellation data.
3565  * \param in_cleanup Whether to clean up tessellation data from representation items.
3566  * \return A reference to this ImportOptionsKit.
3567  */
3568  ModelFileImportOptionsKit & SetTessellationCleanup(bool in_cleanup);
3569 
3575  ModelFileImportOptionsKit & SetTessellationPreservesUVPoints(bool in_state);
3576 
3582  ModelFileImportOptionsKit & SetTessellationMaximumEdgeLength(double in_length);
3583 
3590  ModelFileImportOptionsKit & SetIFCEdges(bool in_state);
3591 
3595  ModelFileImportOptionsKit & SetAnnotationCaptureFitting(AnnotationCaptureFitting in_fitting);
3596 
3609  ModelFileImportOptionsKit & SetLocation(ComponentPath const & in_path, MatrixKit const & in_transform = MatrixKit());
3610 
3616  ModelFileImportOptionsKit & SetSewingTolerance(double in_tolerance);
3617 
3624  ModelFileImportOptionsKit & SetComputePreferredOpenShellOrientation(bool in_state);
3625 
3629  ModelFileImportOptionsKit & SetNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit const & in_nurbs_conversion_options);
3630 
3635  ModelFileImportOptionsKit & SetGeometryDefaultColor(RGBAColor const & in_color);
3636 
3642  ModelFileImportOptionsKit & SetHiddenObjects(bool in_state);
3643 
3646  ModelFileImportOptionsKit & UnsetTessellationLevel();
3647 
3650  ModelFileImportOptionsKit & UnsetTessellationAccuracy();
3651 
3654  ModelFileImportOptionsKit & UnsetTessellationCleanup();
3655 
3658  ModelFileImportOptionsKit & UnsetPMIFlipping();
3659 
3662  ModelFileImportOptionsKit & UnsetTessellationPreservesUVPoints();
3663 
3666  ModelFileImportOptionsKit & UnsetTessellationMaximumEdgeLength();
3667 
3670  ModelFileImportOptionsKit & UnsetIFCEdges();
3671 
3674  ModelFileImportOptionsKit & UnsetAnnotationCaptureFitting();
3675 
3678  ModelFileImportOptionsKit & UnsetLocation();
3679 
3682  ModelFileImportOptionsKit & UnsetSewingTolerance();
3683 
3686  ModelFileImportOptionsKit & UnsetComputePreferredOpenShellOrientation();
3687 
3690  ModelFileImportOptionsKit & UnsetNURBSConversion();
3691 
3694  ModelFileImportOptionsKit & UnsetGeometryDefaultColor();
3695 
3698  ModelFileImportOptionsKit & UnsetHiddenObjects();
3699 
3702  ModelFileImportOptionsKit & UnsetEverything();
3703 
3704 
3712  bool ShowTessellationLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
3713 
3720  bool ShowTessellationAccuracy(Tessellation::Accuracy & out_type, bool & out_accurate_normals, bool & out_accurate_surface_curvatures, double & out_accurate_grid_maximum_stitch_length) const;
3721 
3725  bool ShowTessellationCleanup(bool & out_cleanup) const;
3726 
3730  bool ShowPMIFlipping(bool & out_pmi_flipping) const;
3731 
3735  bool ShowTessellationPreservesUVPoints(bool & out_state) const;
3736 
3740  bool ShowTessellationMaximumEdgeLength(double & out_length) const;
3741 
3745  bool ShowIFCEdges(bool & out_state) const;
3746 
3750  bool ShowAnnotationCaptureFitting(AnnotationCaptureFitting & out_fitting) const;
3751 
3756  bool ShowLocation(ComponentPath & out_path, MatrixKit & out_transform) const;
3757 
3761  bool ShowSewingTolerance(double & out_tolerance) const;
3762 
3763 
3767  bool ShowComputePreferredOpenShellOrientation(bool & out_state) const;
3768 
3772  bool ShowNURBSConversion(HPS::Exchange::NURBSConversionOptionsKit & out_nurbs_conversion_options) const;
3773 
3777  bool ShowGeometryDefaultColor(RGBAColor & out_color) const;
3778 
3782  bool ShowHiddenObjects(bool & out_state) const;
3783  };
3784 
3785 #if TARGET_OS_ANDROID == 0 && TARGET_OS_IPHONE == 0
3786 
3787  class EXCHANGE_API Export3MFOptionsKit : public SprocketKit
3788  {
3789  public:
3791  Export3MFOptionsKit();
3792 
3795  Export3MFOptionsKit(Export3MFOptionsKit const & in_kit);
3796 
3799  Export3MFOptionsKit(Export3MFOptionsKit && in_that);
3800 
3801  virtual ~Export3MFOptionsKit();
3802 
3803  static const HPS::Type staticType = HPS::Type::ExchangeExport3MFOptionsKit;
3804  HPS::Type ObjectType() const { return staticType; }
3805 
3809  static Export3MFOptionsKit GetDefault();
3810 
3813  void Set(Export3MFOptionsKit const & in_kit);
3814 
3817  void Show(Export3MFOptionsKit& out_kit) const;
3818 
3822  Export3MFOptionsKit & operator=(Export3MFOptionsKit const & in_kit);
3823 
3827  Export3MFOptionsKit & operator=(Export3MFOptionsKit && in_that);
3828 
3831  bool Empty() const;
3832 
3836  bool Equals(Export3MFOptionsKit const & in_kit) const;
3837 
3841  bool operator==(Export3MFOptionsKit const & in_kit) const;
3842 
3846  bool operator!=(Export3MFOptionsKit const & in_kit) const;
3847 
3852  Export3MFOptionsKit & SetAdditionalKeyPaths(KeyPathArray const & in_additional_key_paths);
3853 
3859  Export3MFOptionsKit & SetAdditionalKeyPaths(size_t in_count, KeyPath const in_additional_key_paths[]);
3860 
3863  Export3MFOptionsKit & UnsetAdditionalKeyPaths();
3864 
3868  bool ShowAdditionalKeyPaths(KeyPathArray & out_additional_key_paths) const;
3869 
3874  Export3MFOptionsKit & SetCurrentTessellationRetention(bool in_state, TessellationOptionsKit const & in_tessellation_kit = TessellationOptionsKit());
3875 
3878  Export3MFOptionsKit & UnsetCurrentTessellationRetention();
3879 
3884  bool ShowCurrentTessellationRetention(bool & out_state, Exchange::TessellationOptionsKit & out_tessellation_kit) const;
3885 
3889  Export3MFOptionsKit & SetDescription(char const * in_description);
3890 
3893  Export3MFOptionsKit & UnsetDescription();
3894 
3898  bool ShowDescription(HPS::UTF8 & out_state) const;
3899 
3903  Export3MFOptionsKit & SetCopyright(char const * in_state);
3904 
3907  Export3MFOptionsKit & UnsetCopyright();
3908 
3912  bool ShowCopyright(HPS::UTF8 & out_state) const;
3913 
3917  Export3MFOptionsKit & SetLicenseTerms(char const * in_license);
3918 
3921  Export3MFOptionsKit & UnsetLicenseTerms();
3922 
3926  bool ShowLicenseTerms(HPS::UTF8 & out_license) const;
3927 
3930  Export3MFOptionsKit & UnsetEverything();
3931  };
3932 
3934  class EXCHANGE_API ExportFBXOptionsKit : public SprocketKit
3935  {
3936  public:
3938  ExportFBXOptionsKit();
3939 
3942  ExportFBXOptionsKit(ExportFBXOptionsKit const & in_kit);
3943 
3946  ExportFBXOptionsKit(ExportFBXOptionsKit && in_that);
3947 
3948  virtual ~ExportFBXOptionsKit();
3949 
3950  static const HPS::Type staticType = HPS::Type::ExchangeExportFBXOptionsKit;
3951  HPS::Type ObjectType() const { return staticType; }
3952 
3956  static ExportFBXOptionsKit GetDefault();
3957 
3960  void Set(ExportFBXOptionsKit const & in_kit);
3961 
3964  void Show(ExportFBXOptionsKit & out_kit) const;
3965 
3969  ExportFBXOptionsKit & operator=(ExportFBXOptionsKit const & in_kit);
3970 
3974  ExportFBXOptionsKit & operator=(ExportFBXOptionsKit && in_that);
3975 
3978  bool Empty() const;
3979 
3983  bool Equals(ExportFBXOptionsKit const & in_kit) const;
3984 
3988  bool operator==(ExportFBXOptionsKit const & in_kit) const;
3989 
3993  bool operator!=(ExportFBXOptionsKit const & in_kit) const;
3994 
3995 
4003  ExportFBXOptionsKit & SetTextureFolder(char const * in_name);
4004 
4005 
4011  ExportFBXOptionsKit & SetAscii(bool in_state);
4012 
4013 
4016  ExportFBXOptionsKit & UnsetTextureFolder();
4017 
4020  ExportFBXOptionsKit & UnsetAscii();
4021 
4024  ExportFBXOptionsKit & UnsetEverything();
4025 
4026 
4030  bool ShowTextureFolder(UTF8 & out_path) const;
4031 
4035  bool ShowAscii(bool & out_state) const;
4036  };
4037 
4039  class EXCHANGE_API ExportACISOptionsKit : public SprocketKit
4040  {
4041  public:
4043  ExportACISOptionsKit();
4044 
4047  ExportACISOptionsKit(ExportACISOptionsKit const & in_kit);
4048 
4051  ExportACISOptionsKit(ExportACISOptionsKit && in_that);
4052 
4053  virtual ~ExportACISOptionsKit();
4054 
4055  static const HPS::Type staticType = HPS::Type::ExchangeExportACISOptionsKit;
4056  HPS::Type ObjectType() const { return staticType; }
4057 
4061  static ExportACISOptionsKit GetDefault();
4062 
4065  void Set(ExportACISOptionsKit const & in_kit);
4066 
4069  void Show(ExportACISOptionsKit & out_kit) const;
4070 
4074  ExportACISOptionsKit & operator=(ExportACISOptionsKit const & in_kit);
4075 
4079  ExportACISOptionsKit & operator=(ExportACISOptionsKit && in_that);
4080 
4083  bool Empty() const;
4084 
4088  bool Equals(ExportACISOptionsKit const & in_kit) const;
4089 
4093  bool operator==(ExportACISOptionsKit const & in_kit) const;
4094 
4098  bool operator!=(ExportACISOptionsKit const & in_kit) const;
4099 
4100 
4106  ExportACISOptionsKit & SetMillimeterUnits(bool in_state);
4107 
4113  ExportACISOptionsKit & SetBinary(bool in_state);
4114 
4115 
4118  ExportACISOptionsKit & UnsetMillimeterUnits();
4119 
4122  ExportACISOptionsKit & UnsetBinary();
4123 
4126  ExportACISOptionsKit & UnsetEverything();
4127 
4128 
4132  bool ShowMillimeterUnits(bool & out_state) const;
4133 
4137  bool ShowBinary(bool & out_state) const;
4138  };
4139 
4141  class EXCHANGE_API ExportJTOptionsKit : public SprocketKit
4142  {
4143  public:
4145  ExportJTOptionsKit();
4146 
4149  ExportJTOptionsKit(ExportJTOptionsKit const & in_kit);
4150 
4153  ExportJTOptionsKit(ExportJTOptionsKit && in_that);
4154 
4155  virtual ~ExportJTOptionsKit();
4156 
4157  static const HPS::Type staticType = HPS::Type::ExchangeExportJTOptionsKit;
4158  HPS::Type ObjectType() const { return staticType; }
4159 
4163  static ExportJTOptionsKit GetDefault();
4164 
4167  void Set(ExportJTOptionsKit const & in_kit);
4168 
4171  void Show(ExportJTOptionsKit & out_kit) const;
4172 
4176  ExportJTOptionsKit & operator=(ExportJTOptionsKit const & in_kit);
4177 
4181  ExportJTOptionsKit & operator=(ExportJTOptionsKit && in_that);
4182 
4185  bool Empty() const;
4186 
4190  bool Equals(ExportJTOptionsKit const & in_kit) const;
4191 
4195  bool operator==(ExportJTOptionsKit const & in_kit) const;
4196 
4200  bool operator!=(ExportJTOptionsKit const & in_kit) const;
4201 
4202 
4208  ExportJTOptionsKit & SetContent(JT::Content in_content);
4209 
4215  ExportJTOptionsKit & SetHiddenObjects(bool in_state);
4216 
4222  ExportJTOptionsKit & SetPMI(bool in_state);
4223 
4229  ExportJTOptionsKit & SetVersion(JT::Version in_version);
4230 
4231 
4234  ExportJTOptionsKit & UnsetContent();
4235 
4238  ExportJTOptionsKit & UnsetHiddenObjects();
4239 
4242  ExportJTOptionsKit & UnsetPMI();
4243 
4246  ExportJTOptionsKit & UnsetVersion();
4247 
4250  ExportJTOptionsKit & UnsetEverything();
4251 
4252 
4256  bool ShowContent(JT::Content & out_content) const;
4257 
4261  bool ShowHiddenObjects(bool & out_state) const;
4262 
4266  bool ShowPMI(bool & out_state) const;
4267 
4271  bool ShowVersion(JT::Version & out_version) const;
4272  };
4273 
4275  class EXCHANGE_API ExportPRCOptionsKit : public SprocketKit
4276  {
4277  public:
4279  ExportPRCOptionsKit();
4280 
4283  ExportPRCOptionsKit(ExportPRCOptionsKit const & in_kit);
4284 
4287  ExportPRCOptionsKit(ExportPRCOptionsKit && in_that);
4288 
4289  virtual ~ExportPRCOptionsKit();
4290 
4291  static const HPS::Type staticType = HPS::Type::ExchangeExportPRCOptionsKit;
4292  HPS::Type ObjectType() const { return staticType; }
4293 
4297  static ExportPRCOptionsKit GetDefault();
4298 
4301  void Set(ExportPRCOptionsKit const & in_kit);
4302 
4305  void Show(ExportPRCOptionsKit & out_kit) const;
4306 
4310  ExportPRCOptionsKit & operator=(ExportPRCOptionsKit const & in_kit);
4311 
4315  ExportPRCOptionsKit & operator=(ExportPRCOptionsKit && in_that);
4316 
4319  bool Empty() const;
4320 
4324  bool Equals(ExportPRCOptionsKit const & in_kit) const;
4325 
4329  bool operator==(ExportPRCOptionsKit const & in_kit) const;
4330 
4334  bool operator!=(ExportPRCOptionsKit const & in_kit) const;
4335 
4336 
4342  ExportPRCOptionsKit & SetTessellationCompression(bool in_state);
4343 
4350  ExportPRCOptionsKit & SetBRepCompression(PRC::BRepCompression in_level);
4351 
4357  ExportPRCOptionsKit & SetBRepRemoval(bool in_state);
4358 
4364  ExportPRCOptionsKit & SetAttributeRemoval(bool in_state);
4365 
4370  ExportPRCOptionsKit & SetAdditionalKeyPaths(KeyPathArray const & in_additional_key_paths);
4371 
4377  ExportPRCOptionsKit & SetAdditionalKeyPaths(size_t in_count, KeyPath const in_additional_key_paths []);
4378 
4379 
4382  ExportPRCOptionsKit & UnsetTessellationCompression();
4383 
4386  ExportPRCOptionsKit & UnsetBRepCompression();
4387 
4390  ExportPRCOptionsKit & UnsetBRepRemoval();
4391 
4394  ExportPRCOptionsKit & UnsetAttributeRemoval();
4395 
4398  ExportPRCOptionsKit & UnsetAdditionalKeyPaths();
4399 
4402  ExportPRCOptionsKit & UnsetEverything();
4403 
4404 
4408  bool ShowTessellationCompression(bool & out_state) const;
4409 
4413  bool ShowBRepCompression(PRC::BRepCompression & out_level) const;
4414 
4418  bool ShowBRepRemoval(bool & out_state) const;
4419 
4423  bool ShowAttributeRemoval(bool & out_state) const;
4424 
4428  bool ShowAdditionalKeyPaths(KeyPathArray & out_additional_key_paths) const;
4429  };
4430 
4432  class EXCHANGE_API ExportSTLOptionsKit : public SprocketKit
4433  {
4434  public:
4436  ExportSTLOptionsKit();
4437 
4440  ExportSTLOptionsKit(ExportSTLOptionsKit const & in_kit);
4441 
4444  ExportSTLOptionsKit(ExportSTLOptionsKit && in_that);
4445 
4446  virtual ~ExportSTLOptionsKit();
4447 
4448  static const HPS::Type staticType = HPS::Type::ExchangeExportSTLOptionsKit;
4449  HPS::Type ObjectType() const { return staticType; }
4450 
4454  static ExportSTLOptionsKit GetDefault();
4455 
4458  void Set(ExportSTLOptionsKit const & in_kit);
4459 
4462  void Show(ExportSTLOptionsKit & out_kit) const;
4463 
4467  ExportSTLOptionsKit & operator=(ExportSTLOptionsKit const & in_kit);
4468 
4472  ExportSTLOptionsKit & operator=(ExportSTLOptionsKit && in_that);
4473 
4476  bool Empty() const;
4477 
4481  bool Equals(ExportSTLOptionsKit const & in_kit) const;
4482 
4486  bool operator==(ExportSTLOptionsKit const & in_kit) const;
4487 
4491  bool operator!=(ExportSTLOptionsKit const & in_kit) const;
4492 
4493 
4499  ExportSTLOptionsKit & SetBinary(bool in_state);
4500 
4506  ExportSTLOptionsKit & SetTessellationLevel(Tessellation::Level in_level);
4507 
4514  ExportSTLOptionsKit & SetTessellationLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
4515 
4521  ExportSTLOptionsKit & SetTessellationAccuracy(Tessellation::Accuracy in_type);
4522 
4528  ExportSTLOptionsKit & SetCurrentTessellationRetention(bool in_state);
4529 
4536  ExportSTLOptionsKit & SetMaximumEdgeLength(double in_length);
4537 
4547  ExportSTLOptionsKit & SetUnits(Units in_units);
4548 
4549 
4552  ExportSTLOptionsKit & UnsetBinary();
4553 
4556  ExportSTLOptionsKit & UnsetTessellationLevel();
4557 
4560  ExportSTLOptionsKit & UnsetTessellationAccuracy();
4561 
4564  ExportSTLOptionsKit & UnsetCurrentTessellationRetention();
4565 
4568  ExportSTLOptionsKit & UnsetMaximumEdgeLength();
4569 
4572  ExportSTLOptionsKit & UnsetUnits();
4573 
4576  ExportSTLOptionsKit & UnsetEverything();
4577 
4578 
4582  bool ShowBinary(bool & out_state) const;
4583 
4591  bool ShowTessellationLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
4592 
4596  bool ShowTessellationAccuracy(Tessellation::Accuracy & out_type) const;
4597 
4601  bool ShowCurrentTessellationRetention(bool & out_state) const;
4602 
4606  bool ShowMaximumEdgeLength(double & out_length) const;
4607 
4611  bool ShowUnits(Units & out_units) const;
4612  };
4613 
4615  class EXCHANGE_API ExportOBJOptionsKit : public SprocketKit
4616  {
4617  public:
4619  ExportOBJOptionsKit();
4620 
4623  ExportOBJOptionsKit(ExportOBJOptionsKit const & in_kit);
4624 
4627  ExportOBJOptionsKit(ExportOBJOptionsKit && in_that);
4628 
4629  virtual ~ExportOBJOptionsKit();
4630 
4631  static const HPS::Type staticType = HPS::Type::ExchangeExportOBJOptionsKit;
4632  HPS::Type ObjectType() const { return staticType; }
4633 
4637  static ExportOBJOptionsKit GetDefault();
4638 
4641  void Set(ExportOBJOptionsKit const & in_kit);
4642 
4645  void Show(ExportOBJOptionsKit & out_kit) const;
4646 
4650  ExportOBJOptionsKit & operator=(ExportOBJOptionsKit const & in_kit);
4651 
4655  ExportOBJOptionsKit & operator=(ExportOBJOptionsKit && in_that);
4656 
4659  bool Empty() const;
4660 
4664  bool Equals(ExportOBJOptionsKit const & in_kit) const;
4665 
4669  bool operator==(ExportOBJOptionsKit const & in_kit) const;
4670 
4674  bool operator!=(ExportOBJOptionsKit const & in_kit) const;
4675 
4680  ExportOBJOptionsKit & SetTextureFolder(char const * in_name);
4681 
4685  bool ShowTextureFolder(UTF8 & out_path) const;
4686 
4689  ExportOBJOptionsKit & UnsetTextureFolder();
4690 
4693  ExportOBJOptionsKit & UnsetEverything();
4694  };
4695 
4697  class EXCHANGE_API ExportU3DOptionsKit : public SprocketKit
4698  {
4699  public:
4701  ExportU3DOptionsKit();
4702 
4705  ExportU3DOptionsKit(ExportU3DOptionsKit const & in_kit);
4706 
4709  ExportU3DOptionsKit(ExportU3DOptionsKit && in_that);
4710 
4711  virtual ~ExportU3DOptionsKit();
4712 
4713  static const HPS::Type staticType = HPS::Type::ExchangeExportU3DOptionsKit;
4714  HPS::Type ObjectType() const { return staticType; }
4715 
4719  static ExportU3DOptionsKit GetDefault();
4720 
4723  void Set(ExportU3DOptionsKit const & in_kit);
4724 
4727  void Show(ExportU3DOptionsKit & out_kit) const;
4728 
4732  ExportU3DOptionsKit & operator=(ExportU3DOptionsKit const & in_kit);
4733 
4737  ExportU3DOptionsKit & operator=(ExportU3DOptionsKit && in_that);
4738 
4741  bool Empty() const;
4742 
4746  bool Equals(ExportU3DOptionsKit const & in_kit) const;
4747 
4751  bool operator==(ExportU3DOptionsKit const & in_kit) const;
4752 
4756  bool operator!=(ExportU3DOptionsKit const & in_kit) const;
4757 
4758 
4764  ExportU3DOptionsKit & SetVersion(U3D::Version in_version);
4765 
4770  ExportU3DOptionsKit & SetCompression(unsigned char in_level);
4771 
4772 
4775  ExportU3DOptionsKit & UnsetVersion();
4776 
4779  ExportU3DOptionsKit & UnsetCompression();
4780 
4783  ExportU3DOptionsKit & UnsetEverything();
4784 
4785 
4789  bool ShowVersion(U3D::Version & out_version) const;
4790 
4794  bool ShowCompression(unsigned char & out_level) const;
4795  };
4796 
4798  class EXCHANGE_API ExportXMLOptionsKit : public SprocketKit
4799  {
4800  public:
4802  ExportXMLOptionsKit();
4803 
4806  ExportXMLOptionsKit(ExportXMLOptionsKit const & in_kit);
4807 
4810  ExportXMLOptionsKit(ExportXMLOptionsKit && in_that);
4811 
4812  virtual ~ExportXMLOptionsKit();
4813 
4814  static const HPS::Type staticType = HPS::Type::ExchangeExportXMLOptionsKit;
4815  HPS::Type ObjectType() const { return staticType; }
4816 
4820  static ExportXMLOptionsKit GetDefault();
4821 
4824  void Set(ExportXMLOptionsKit const & in_kit);
4825 
4828  void Show(ExportXMLOptionsKit & out_kit) const;
4829 
4833  ExportXMLOptionsKit & operator=(ExportXMLOptionsKit const & in_kit);
4834 
4838  ExportXMLOptionsKit & operator=(ExportXMLOptionsKit && in_that);
4839 
4842  bool Empty() const;
4843 
4847  bool Equals(ExportXMLOptionsKit const & in_kit) const;
4848 
4852  bool operator==(ExportXMLOptionsKit const & in_kit) const;
4853 
4857  bool operator!=(ExportXMLOptionsKit const & in_kit) const;
4858 
4859 
4865  ExportXMLOptionsKit & SetMetadata(bool in_state);
4866 
4872  ExportXMLOptionsKit & SetTransformations(bool in_state);
4873 
4879  ExportXMLOptionsKit & SetMaterials(bool in_state);
4880 
4881 
4884  ExportXMLOptionsKit & UnsetMetadata();
4885 
4888  ExportXMLOptionsKit & UnsetTransformations();
4889 
4892  ExportXMLOptionsKit & UnsetMaterials();
4893 
4896  ExportXMLOptionsKit & UnsetEverything();
4897 
4898 
4902  bool ShowMetadata(bool & out_state) const;
4903 
4907  bool ShowTransformations(bool & out_state) const;
4908 
4912  bool ShowMaterials(bool & out_state) const;
4913  };
4914 #endif
4915 
4916 #if !defined(TARGET_OS_ANDROID)
4917 
4918  class EXCHANGE_API ExportIGESOptionsKit : public SprocketKit
4919  {
4920  public:
4922  ExportIGESOptionsKit();
4923 
4926  ExportIGESOptionsKit(ExportIGESOptionsKit const & in_kit);
4927 
4930  ExportIGESOptionsKit(ExportIGESOptionsKit && in_that);
4931 
4932  virtual ~ExportIGESOptionsKit();
4933 
4934  static const HPS::Type staticType = HPS::Type::ExchangeExportIGESOptionsKit;
4935  HPS::Type ObjectType() const { return staticType; }
4936 
4940  static ExportIGESOptionsKit GetDefault();
4941 
4944  void Set(ExportIGESOptionsKit const & in_kit);
4945 
4948  void Show(ExportIGESOptionsKit & out_kit) const;
4949 
4953  ExportIGESOptionsKit & operator=(ExportIGESOptionsKit const & in_kit);
4954 
4958  ExportIGESOptionsKit & operator=(ExportIGESOptionsKit && in_that);
4959 
4962  bool Empty() const;
4963 
4967  bool Equals(ExportIGESOptionsKit const & in_kit) const;
4968 
4972  bool operator==(ExportIGESOptionsKit const & in_kit) const;
4973 
4977  bool operator!=(ExportIGESOptionsKit const & in_kit) const;
4978 
4979 
4985  ExportIGESOptionsKit & SetAnalyticsAsNURBS(bool in_state);
4986 
4992  ExportIGESOptionsKit & SetFacetedAsWireframe(bool in_state);
4993 
4999  ExportIGESOptionsKit & SetSolidsAsFaces(bool in_state);
5000 
5006  ExportIGESOptionsKit & SetHiddenObjects(bool in_state);
5007 
5013  ExportIGESOptionsKit & SetTessellation(bool in_state);
5014 
5018  ExportIGESOptionsKit & SetApplication(char const * in_name);
5019 
5023  ExportIGESOptionsKit & SetVersion(char const * in_version);
5024 
5025 
5028  ExportIGESOptionsKit & UnsetAnalyticsAsNURBS();
5029 
5032  ExportIGESOptionsKit & UnsetFacetedAsWireframe();
5033 
5036  ExportIGESOptionsKit & UnsetSolidsAsFaces();
5037 
5040  ExportIGESOptionsKit & UnsetHiddenObjects();
5041 
5044  ExportIGESOptionsKit & UnsetTessellation();
5045 
5048  ExportIGESOptionsKit & UnsetApplication();
5049 
5052  ExportIGESOptionsKit & UnsetVersion();
5053 
5056  ExportIGESOptionsKit & UnsetEverything();
5057 
5058 
5062  bool ShowAnalyticsAsNURBS(bool & out_state) const;
5063 
5067  bool ShowFacetedAsWireframe(bool & out_state) const;
5068 
5072  bool ShowSolidsAsFaces(bool & out_state) const;
5073 
5077  bool ShowHiddenObjects(bool & out_state) const;
5078 
5082  bool ShowTessellation(bool & out_state) const;
5083 
5087  bool ShowApplication(UTF8 & out_name) const;
5088 
5092  bool ShowVersion(UTF8 & out_version) const;
5093  };
5094 
5096  class EXCHANGE_API ExportParasolidOptionsKit : public SprocketKit
5097  {
5098  public:
5100  ExportParasolidOptionsKit();
5101 
5104  ExportParasolidOptionsKit(ExportParasolidOptionsKit const & in_kit);
5105 
5108  ExportParasolidOptionsKit(ExportParasolidOptionsKit && in_that);
5109 
5110  virtual ~ExportParasolidOptionsKit();
5111 
5112  static const HPS::Type staticType = HPS::Type::ExchangeExportParasolidOptionsKit;
5113  HPS::Type ObjectType() const { return staticType; }
5114 
5118  static ExportParasolidOptionsKit GetDefault();
5119 
5122  void Set(ExportParasolidOptionsKit const & in_kit);
5123 
5126  void Show(ExportParasolidOptionsKit & out_kit) const;
5127 
5131  ExportParasolidOptionsKit & operator=(ExportParasolidOptionsKit const & in_kit);
5132 
5136  ExportParasolidOptionsKit & operator=(ExportParasolidOptionsKit && in_that);
5137 
5140  bool Empty() const;
5141 
5145  bool Equals(ExportParasolidOptionsKit const & in_kit) const;
5146 
5150  bool operator==(ExportParasolidOptionsKit const & in_kit) const;
5151 
5155  bool operator!=(ExportParasolidOptionsKit const & in_kit) const;
5156 
5157 
5163  ExportParasolidOptionsKit & SetSolidsAsFaces(bool in_state);
5164 
5170  ExportParasolidOptionsKit & SetTessellation(bool in_state);
5171 
5177  ExportParasolidOptionsKit & SetHiddenObjects(bool in_state);
5178 
5182  ExportParasolidOptionsKit & SetApplication(char const * in_name);
5183 
5187  ExportParasolidOptionsKit & SetVersion(char const * in_version);
5188 
5194  ExportParasolidOptionsKit& SetExplodeMultiBodies(bool in_state);
5195 
5198  ExportParasolidOptionsKit & UnsetSolidsAsFaces();
5199 
5202  ExportParasolidOptionsKit & UnsetTessellation();
5203 
5206  ExportParasolidOptionsKit & UnsetHiddenObjects();
5207 
5210  ExportParasolidOptionsKit & UnsetApplication();
5211 
5214  ExportParasolidOptionsKit & UnsetVersion();
5215 
5218  ExportParasolidOptionsKit& UnsetExplodeMultiBodies();
5219 
5222  ExportParasolidOptionsKit & UnsetEverything();
5223 
5224 
5228  bool ShowSolidsAsFaces(bool & out_state) const;
5229 
5233  bool ShowTessellation(bool & out_state) const;
5234 
5238  bool ShowHiddenObjects(bool & out_state) const;
5239 
5243  bool ShowApplication(UTF8 & out_name) const;
5244 
5248  bool ShowVersion(UTF8 & out_version) const;
5249 
5253  bool ShowExplodeMultiBodies(bool& out_state) const;
5254  };
5255 
5257  class EXCHANGE_API ExportSTEPOptionsKit : public SprocketKit
5258  {
5259  public:
5261  ExportSTEPOptionsKit();
5262 
5265  ExportSTEPOptionsKit(ExportSTEPOptionsKit const & in_kit);
5266 
5269  ExportSTEPOptionsKit(ExportSTEPOptionsKit && in_that);
5270 
5271  virtual ~ExportSTEPOptionsKit();
5272 
5273  static const HPS::Type staticType = HPS::Type::ExchangeExportSTEPOptionsKit;
5274  HPS::Type ObjectType() const { return staticType; }
5275 
5279  static ExportSTEPOptionsKit GetDefault();
5280 
5283  void Set(ExportSTEPOptionsKit const & in_kit);
5284 
5287  void Show(ExportSTEPOptionsKit & out_kit) const;
5288 
5292  ExportSTEPOptionsKit & operator=(ExportSTEPOptionsKit const & in_kit);
5293 
5297  ExportSTEPOptionsKit & operator=(ExportSTEPOptionsKit && in_that);
5298 
5301  bool Empty() const;
5302 
5306  bool Equals(ExportSTEPOptionsKit const & in_kit) const;
5307 
5311  bool operator==(ExportSTEPOptionsKit const & in_kit) const;
5312 
5316  bool operator!=(ExportSTEPOptionsKit const & in_kit) const;
5317 
5318 
5324  ExportSTEPOptionsKit & SetFormat(STEP::Format in_format);
5325 
5331  ExportSTEPOptionsKit & SetAnalyticsAsNURBS(bool in_state);
5332 
5338  ExportSTEPOptionsKit & SetFacetedAsWireframe(bool in_state);
5339 
5345  ExportSTEPOptionsKit & SetNameShortening(bool in_state);
5346 
5350  ExportSTEPOptionsKit & SetApplication(char const * in_name);
5351 
5355  ExportSTEPOptionsKit & SetVersion(char const * in_version);
5356 
5360  ExportSTEPOptionsKit & SetPMI(bool in_state);
5361 
5365  ExportSTEPOptionsKit & SetCurves(bool in_state);
5366 
5370  ExportSTEPOptionsKit & SetAttributes(bool in_state);
5371 
5375  ExportSTEPOptionsKit & SetPMIWithSemantic(bool in_state);
5376 
5380  ExportSTEPOptionsKit & SetPMIAsTessellated(bool in_state);
5381 
5384  ExportSTEPOptionsKit & UnsetFormat();
5385 
5388  ExportSTEPOptionsKit & UnsetAnalyticsAsNURBS();
5389 
5392  ExportSTEPOptionsKit & UnsetFacetedAsWireframe();
5393 
5396  ExportSTEPOptionsKit & UnsetNameShortening();
5397 
5400  ExportSTEPOptionsKit & UnsetApplication();
5401 
5404  ExportSTEPOptionsKit & UnsetVersion();
5405 
5408  ExportSTEPOptionsKit & UnsetPMI();
5409 
5412  ExportSTEPOptionsKit & UnsetCurves();
5413 
5416  ExportSTEPOptionsKit & UnsetAttributes();
5417 
5420  ExportSTEPOptionsKit & UnsetPMIWithSemantic();
5421 
5424  ExportSTEPOptionsKit & UnsetPMIAsTessellated();
5425 
5428  ExportSTEPOptionsKit & UnsetEverything();
5429 
5430 
5434  bool ShowFormat(STEP::Format & out_format) const;
5435 
5439  bool ShowAnalyticsAsNURBS(bool & out_state) const;
5440 
5444  bool ShowFacetedAsWireframe(bool & out_state) const;
5445 
5449  bool ShowNameShortening(bool & out_state) const;
5450 
5454  bool ShowApplication(UTF8 & out_name) const;
5455 
5459  bool ShowVersion(UTF8 & out_version) const;
5460 
5464  bool ShowPMI(bool & out_state) const;
5465 
5469  bool ShowCurves(bool & out_state) const;
5470 
5474  bool ShowAttributes(bool & out_state) const;
5475 
5479  bool ShowPMIWithSemantic(bool & out_state) const;
5480 
5484  bool ShowPMIAsTessellated(bool & out_state) const;
5485  };
5486 
5488  class EXCHANGE_API ExportGLTFOptionsKit : public SprocketKit
5489  {
5490  public:
5492  ExportGLTFOptionsKit();
5493 
5496  ExportGLTFOptionsKit(ExportGLTFOptionsKit const & in_kit);
5497 
5500  ExportGLTFOptionsKit(ExportGLTFOptionsKit && in_that);
5501 
5502  virtual ~ExportGLTFOptionsKit();
5503 
5504  static const HPS::Type staticType = HPS::Type::ExchangeExportGLTFOptionsKit;
5505  HPS::Type ObjectType() const { return staticType; }
5506 
5510  static ExportGLTFOptionsKit GetDefault();
5511 
5514  void Set(ExportGLTFOptionsKit const & in_kit);
5515 
5518  void Show(ExportGLTFOptionsKit & out_kit) const;
5519 
5523  ExportGLTFOptionsKit & operator=(ExportGLTFOptionsKit const & in_kit);
5524 
5528  ExportGLTFOptionsKit & operator=(ExportGLTFOptionsKit && in_that);
5529 
5532  bool Empty() const;
5533 
5537  bool Equals(ExportGLTFOptionsKit const & in_kit) const;
5538 
5542  bool operator==(ExportGLTFOptionsKit const & in_kit) const;
5543 
5547  bool operator!=(ExportGLTFOptionsKit const & in_kit) const;
5548 
5549 
5557  ExportGLTFOptionsKit & SetTextureFolder(char const * in_name);
5558 
5559 
5565  ExportGLTFOptionsKit & SetAscii(bool in_state);
5566 
5567 
5570  ExportGLTFOptionsKit & UnsetTextureFolder();
5571 
5574  ExportGLTFOptionsKit & UnsetAscii();
5575 
5578  ExportGLTFOptionsKit & UnsetEverything();
5579 
5580 
5584  bool ShowTextureFolder(UTF8 & out_path) const;
5585 
5589  bool ShowAscii(bool & out_state) const;
5590  };
5591 #endif
5592 
5594  class EXCHANGE_API TessellationOptionsKit : public SprocketKit
5595  {
5596  public:
5598  TessellationOptionsKit();
5599 
5602  TessellationOptionsKit(TessellationOptionsKit const & in_kit);
5603 
5606  TessellationOptionsKit(TessellationOptionsKit && in_that);
5607 
5608  virtual ~TessellationOptionsKit();
5609 
5610  static const HPS::Type staticType = HPS::Type::ExchangeTessellationOptionsKit;
5611  HPS::Type ObjectType() const { return staticType; }
5612 
5616  static TessellationOptionsKit GetDefault();
5617 
5620  void Set(TessellationOptionsKit const & in_kit);
5621 
5624  void Show(TessellationOptionsKit & out_kit) const;
5625 
5629  TessellationOptionsKit & operator=(TessellationOptionsKit const & in_kit);
5630 
5634  TessellationOptionsKit & operator=(TessellationOptionsKit && in_that);
5635 
5638  bool Empty() const;
5639 
5643  bool Equals(TessellationOptionsKit const & in_kit) const;
5644 
5648  bool operator==(TessellationOptionsKit const & in_kit) const;
5649 
5653  bool operator!=(TessellationOptionsKit const & in_kit) const;
5654 
5655 
5659  TessellationOptionsKit & SetLevel(Tessellation::Level in_level);
5660 
5667  TessellationOptionsKit & SetLevel(Tessellation::Chord::Limit in_limit_type, double in_limit, double in_angle_tolerance);
5668 
5678  TessellationOptionsKit & SetAccuracy(Tessellation::Accuracy in_type, bool in_accurate_normals = true, bool in_accurate_surface_curvatures = false, double in_accurate_grid_maximum_stitch_length = 0.0);
5679 
5683  TessellationOptionsKit & SetUVPointPreservation(bool in_state);
5684 
5688  TessellationOptionsKit & SetMaximumEdgeLength(double in_length);
5689 
5690 
5693  TessellationOptionsKit & UnsetLevel();
5694 
5697  TessellationOptionsKit & UnsetAccuracy();
5698 
5701  TessellationOptionsKit & UnsetUVPointPreservation();
5702 
5705  TessellationOptionsKit & UnsetMaximumEdgeLength();
5706 
5709  TessellationOptionsKit & UnsetEverything();
5710 
5711 
5719  bool ShowLevel(Tessellation::Type & out_type, Tessellation::Level & out_level, Tessellation::Chord::Limit & out_limit_type, double & out_limit, double & out_angle_tolerance) const;
5720 
5727  bool ShowAccuracy(Tessellation::Accuracy & out_type, bool & out_accurate_normals, bool & out_accurate_surface_curvatures, double & out_accurate_grid_maximum_stitch_length) const;
5728 
5732  bool ShowUVPointPreservation(bool & out_state) const;
5733 
5737  bool ShowMaximumEdgeLength(double & out_length) const;
5738  };
5739 
5745  class EXCHANGE_API CommonMeasurementOperator : public Operator
5746  {
5747  public:
5748  enum class Tags
5749  {
5750  Name = 0,
5751  MeasurementType,
5752  Radius,
5753  Inverted,
5754  VectorX,
5755  VectorY,
5756  VectorZ,
5757  };
5758 
5759  CommonMeasurementOperator();
5760 
5761  CommonMeasurementOperator(Exchange::CADModel const & in_cad_model, MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
5762 
5764  virtual HPS::UTF8 GetName() const override { return "HPS_ExchangeCommonMeasurementOperator"; }
5765 
5766  virtual void OnViewAttached(HPS::View const & in_attached_view) override;
5767  virtual void OnViewDetached(HPS::View const & in_detached_view) override;
5768 
5769  Exchange::CADModel GetCADModel() const;
5770  void SetCADModel(Exchange::CADModel const & in_cad_model);
5771 
5773  size_t GetPrecision() const;
5774 
5777  void SetPrecision(size_t in_precision);
5778 
5780  MaterialMappingKit GetMaterial() const;
5781 
5784  void SetMaterial(MaterialMappingKit const & in_material_mapping);
5785 
5787  TextAttributeKit GetTextAttributes() const;
5788 
5791  void SetTextAttribute(TextAttributeKit const & in_text_attributes);
5792 
5794  SegmentKey GetMeasurementSegment() const;
5795 
5797  static UTF8 GetNewMeasurementSegmentName(HPS::UTF8 const & in_prefix);
5798 
5799  /* Deletes all measurements */
5800  void DeleteMeasurements();
5801 
5802  class EXCHANGE_API MeasurementInsertedEvent : public HPS::Event
5803  {
5804  public:
5806  MeasurementInsertedEvent() : Event()
5807  {
5808  channel = GetClassID();
5809  consumable = false;
5810  }
5811 
5812  MeasurementInsertedEvent(HPS::Key const & in_measurement_key, HPS::View const & in_view) : Event()
5813  {
5814  channel = GetClassID();
5815  consumable = false;
5816  measurement_key = in_measurement_key;
5817  view = in_view;
5818  }
5819 
5822  MeasurementInsertedEvent(Event const & in_event) : Event(in_event)
5823  {
5824  if (in_event.GetChannel() == Object::ClassID<MeasurementInsertedEvent>())
5825  {
5826  auto that = static_cast<MeasurementInsertedEvent const &>(in_event);
5827  measurement_key = that.measurement_key;
5828  view = that.view;
5829  }
5830  else
5831  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
5832  }
5833 
5834  ~MeasurementInsertedEvent();
5835 
5838  Event * Clone() const
5839  {
5840  MeasurementInsertedEvent * new_event = new MeasurementInsertedEvent(*this);
5841  return new_event;
5842  }
5843 
5844  Key measurement_key;
5845  View view;
5846  };
5847 
5848  class EXCHANGE_API MeasurementDeletedEvent : public HPS::Event
5849  {
5850  public:
5852  MeasurementDeletedEvent() : Event()
5853  {
5854  channel = GetClassID();
5855  consumable = false;
5856  }
5857 
5858  MeasurementDeletedEvent(HPS::UTF8 const & in_measurement_name, HPS::View const & in_view) : Event()
5859  {
5860  channel = GetClassID();
5861  consumable = false;
5862  measurement_name = in_measurement_name;
5863  view = in_view;
5864  }
5865 
5868  MeasurementDeletedEvent(Event const & in_event) : Event(in_event)
5869  {
5870  if (in_event.GetChannel() == Object::ClassID<MeasurementDeletedEvent>())
5871  {
5872  auto that = static_cast<MeasurementDeletedEvent const &>(in_event);
5873  measurement_name = that.measurement_name;
5874  view = that.view;
5875  }
5876  else
5877  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
5878  }
5879 
5880  ~MeasurementDeletedEvent();
5881 
5884  Event * Clone() const
5885  {
5886  MeasurementDeletedEvent * new_event = new MeasurementDeletedEvent(*this);
5887  return new_event;
5888  }
5889 
5890  UTF8 measurement_name;
5891  View view;
5892  };
5893 
5894  protected:
5895  Exchange::CADModel cad_model;
5896  size_t measurement_precision;
5897  UTF8 units;
5898  MaterialMappingKit materials;
5899  TextAttributeKit text_attributes;
5900  SegmentKey measurement_segment;
5901  GlyphDefinition left_arrow;
5902  GlyphDefinition right_arrow;
5903  SelectionOptionsKit selection_options;
5904  bool manipulate_measurement; //whether we are manipulating a previously entered measurement
5905  Vector camera_direction;
5906  PortfolioKey portfolio;
5907  SegmentKey style_segment;
5908  HighlightOptionsKit highlight_options;
5909 
5910  static size_t length_measurement_index;
5911  static size_t radius_measurement_index;
5912  static size_t distance_measurement_index;
5913  static size_t angle_measurement_index;
5914 
5915  void Tag(HPS::Key & tag, const char * message, Tags tag_index);
5916  void GetUnits();
5917  void SetGlyphColor();
5918  void GetCameraDirection();
5919  void SetupConstructionSegment();
5920  void PositionLinearMeasurementGeometry(WindowPoint const & window_cursor_location, KeyPath const & event_path, LineKey & leader_line_one, LineKey & leader_line_two,
5921  LineKey & measurement_line, LineKey & line_to_cursor, Point & original_point_one, Point & original_point_two, TextKey & text, UTF8 const & text_string,
5922  Point & distance_point_one, Point & distance_point_two, SegmentKey & current_measurement_segment, Plane const & measurement_plane = Plane(), Vector const & explicit_direction = Vector());
5923  float GetModelScale(Exchange::Component const & component);
5924  void SetMaterialsOnMeasurementSegment(HPS::SegmentKey const & set_materials_here, HPS::MaterialMappingKit const & materials_to_apply);
5925  };
5926 
5979  class EXCHANGE_API MeasurementOperator : public CommonMeasurementOperator
5980  {
5981  public:
5982  enum class MeasurementType
5983  {
5984  PointToPoint,
5985  EdgeAndRadius,
5986  FeatureToFeature,
5987  FaceAngle,
5988  };
5989 
5990  MeasurementOperator();
5991 
5992  MeasurementOperator(Exchange::CADModel const & in_cad_model, MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
5993 
5995  virtual HPS::UTF8 GetName() const override{ return "HPS_ExchangeMeasurementOperator"; }
5996 
5997  virtual void OnViewAttached(HPS::View const & in_attached_view) override;
5998  virtual void OnViewDetached(HPS::View const & in_detached_view) override;
5999 
6004  virtual bool OnMouseDown(MouseState const & in_state) override;
6005 
6009  virtual bool OnMouseUp(MouseState const & in_state) override;
6010 
6016  virtual bool OnMouseMove(MouseState const & in_state) override;
6017 
6022  virtual bool OnTouchDown(TouchState const & in_state) override;
6023 
6027  virtual bool OnTouchUp(TouchState const & in_state) override;
6028 
6034  virtual bool OnTouchMove(TouchState const & in_state) override;
6035 
6039  virtual bool OnKeyDown(KeyboardState const & in_state) override;
6040 
6043  void SetMeasurementType(MeasurementType in_measurement_type);
6044 
6047  MeasurementType GetMeasurementType();
6048 
6051  void SetMouseOverHighlighting(bool in_highlighting);
6052 
6056  void SetMouseOverHighlighting(bool in_highlighting, HighlightOptionsKit const & in_highlight_options_kit);
6057 
6060  bool GetMouseOverHighlighting();
6061 
6064  HighlightOptionsKit GetHighlightOptions();
6065 
6068  bool IsMeasurementActive();
6069 
6071  void DeleteLastMeasurement();
6072 
6073  private:
6074  enum class EdgeType //used to determine the type of edge measured when using the EdgeAndRadius measurement type
6075  {
6076  Circle,
6077  Line,
6078  Generic,
6079  };
6080 
6081  class Surface //helper class containing surfaces properties. Used for the FeatureToFeature measurement type
6082  {
6083  public:
6084  Surface();
6085 
6086  enum class SurfaceType
6087  {
6088  Plane,
6089  ConeOrCylinder,
6090  Unsupported,
6091  };
6092 
6093  SurfaceType surface_type; //the type of surface being measured
6094  Point center; //the center point of the surface
6095  Vector normal; //the center line of surfaces of type Cylinder or Cone
6096  LineKey normal_points; //the line representing the center line of surfaces of type Cylinder or Cone
6097  ComponentPath path; //the ComponentPath to this surface
6098  };
6099 
6100  //bookkeeping
6101  MeasurementType measurement_type; //the type of measurement to be inserted
6102  MeasurementType temporary_measurement_type; //the type of the measurement to be edited
6103  TouchID tracked_touch_id; //the ID of the touch to track for OnTouchMove operations
6104  TouchID current_touch_id; //the ID of the touch being processed
6105  SegmentKey current_measurement; //segment of the measurement being inserted / edited
6106  bool operator_active; //whether a measurement is in progress
6107  bool end_measurement; //whether we should end the current measurement
6108  CanvasArray canvases; //canvases related to the view where this operator is attached
6109 
6110  //measurement anchors
6111  size_t anchors; //valid for point-to-point and face-angle measurements
6112  bool anchors_in_place; //true if all the anchors have been placed
6113  Point first_click_position; //position of the first anchor
6114  Point second_click_position; //position of the second anchor
6115 
6116  //geometry for linear measurements
6117  MarkerKey anchor_one; //marker corresponding to the start of the measurement
6118  MarkerKey anchor_two; //marker corresponding to the end of the measurement
6119  LineKey distance_line; //a line representing the distance measured
6120  LineKey leader_line_one; //line connecting the first anchor point to the distance line
6121  LineKey leader_line_two; //line connecting the second anchor point to the distance line
6122  Point distance_point_one; //intersection of leader_line_one and distance_line
6123  Point distance_point_two; //intersection of leader_line_two and distance_line
6124  LineKey line_to_cursor; //line extending from distance_point_one to the cursor
6125  TextKey text; //text representing the measurement and units
6126  UTF8 text_string; //the contents of the text
6127  Vector measurement_direction; //the direction of the measurement
6128  bool use_explicit_direction; //if true, we are moving the measurement along a specific vector, called explicit_direction
6129  Vector explicit_direction; //used if use_explicit_direction is true
6130 
6131  //geometry for radius measurement
6132  MarkerKey center_marker; //marker representing the center of the circle
6133  Point circle_center; //circle center
6134  float radius; //circle radius
6135 
6136  //edge specific data
6137  LineKey edge_line; //the edge being measured
6138  double edge_length; //length of the measured edge
6139  EdgeType edge_type; //the type of edge being measured
6140 
6141  //feature-to-feature specific data
6142  Surface surface_one; //data related to first selected surface
6143  Surface surface_two; //data related to second selected surface
6144  Plane measurement_plane; //the measurement plane
6145  LineKey current_normal; //the center line of surfaces of type Cone and Cylinder
6146 
6147  //angle specific data
6148  Vector leader_line_one_direction; //the direction of the first leader line
6149  Vector leader_line_two_direction; //the direction of the second leader line
6150  Vector first_face_normal; //the normal of the first selected face
6151  Vector second_face_normal; //the normal of the second selected face
6152  bool inverted_measurement; //the smallest of the two possible angles is always chosen. If the user wants the other angle, the measurement is marked as 'inverted'
6153  CircularArcKey measurement_arc; //an arc representing the measured angle
6154  LineKey line_to_leader_line; //line extending from one anchor to a leader line
6155  Vector mid_point_direction;
6156 
6157  //selection kits
6158  SelectionOptionsKit point_to_point_selection;
6159  SelectionOptionsKit edge_radius_selection;
6160  SelectionOptionsKit feature_to_feature_selection;
6161  SelectionOptionsKit angle_selection;
6162 
6163  //highlighting
6164  bool highlight_on_mouse_over; //whether measurable geometry should be highlighted on mouse over
6165  HighlightOptionsKit mouse_over_highlight_options; //the options used for mouse over highlighting
6166  HighlightOptionsKit edit_measurement_highlight_options; //the options used for highlighting measurements while editing them
6167  UpdateNotifier highlight_update_notifier; //notifier used to know if the last highlight update has completed
6168  KeyPath highlighted_path; //highlighted_path
6169  bool disable_highlighting; //in some situation we temporarily disable highlighting to improve performance
6170  bool Highlight(MeasurementType in_measurement_type, WindowPoint const & in_location, WindowKey & in_window, KeyPath const & in_path);
6171 
6172  //input handling
6173  bool InputDown(WindowPoint const & in_location, WindowKey & in_window, KeyPath const & in_path, size_t number_of_clicks);
6174  bool InputMove(WindowPoint const & in_location, KeyPath const & in_path);
6175  bool InputUp(WindowKey & in_window);
6176  void ResetMeasurement();
6177 
6178  //inserting measurements
6179  void InsertPointToPointMeasurement(Point const & in_world_point);
6180  bool InsertEdgeRadiusMeasurement(KeyPath const & in_selection_path, WindowPoint & in_selection_position, Key const & in_edge_key);
6181  bool InsertFeatureToFeatureMeasurement(KeyPath const & in_selection_path, WindowPoint & in_selection_position, Key const & in_face_key, WindowKey & in_window);
6182  void InsertFeatureToFeatureGeometry(Point const & point_one, Point const & point_two, float distance);
6183  bool InsertAngleMeasurement(KeyPath const & in_selection_path, WindowPoint & in_selection_position, Key const & in_face_key, WindowKey & in_window, SelectionResults const & in_selection_results);
6184  void InvertMeasuredAngle(WindowKey & in_window);
6185  void AdjustLineToCursor(Point const & cursor_position);
6186 
6187  //saving measurements
6188  void TagMeasurement();
6189  void TagPointToPointMeasurement();
6190  void TagEdgeMeasurement();
6191  void TagRadiusMeasurement();
6192  void TagGenericEdgeMeasurement();
6193  void TagFeatureToFeatureMeasurement();
6194  void TagAngleMeasurement();
6195 
6196  //restoring measurements
6197  void RestoreMeasurement(SegmentKey const & measurement_segment);
6198  void RestorePointToPointMeasurement(SegmentKey const & measurement_segment);
6199  void RestoreEdgeMeasurement(SegmentKey const & measurement_segment);
6200  void RestoreRadiusMeasurement(SegmentKey const & measurement_segment);
6201  void RestoreGenericEdgeMeasurement(SegmentKey const & measurement_segment);
6202  void RestoreFeatureToFeatureMeasurement(SegmentKey const & measurement_segment);
6203  void RestoreAngleMeasurement(SegmentKey const & measurement_segment);
6204 
6205  //topology functions
6206  void GetEdgeLengthAndType(Exchange::Component const & edge_component);
6207  void GetSurfaceType(Exchange::Component const & face_component, Surface & surface);
6208  void PlaneToCenterLineDistance();
6209  void PlaneToPlaneDistance();
6210  void LineToLineDistance();
6211  float LineSegmentDistance(Point & p0, Point & p1, Point & q0, Point & q1, LineKey & normal_one, LineKey & normal_two, Point & out_point_on_edge, Point & out_point_on_center_line, bool clamp = true);
6212  Point ClosestPointOnTriangleToPoint(Point const & p, Point const & a, Point const & b, Point const & c);
6213  float ClosestPointSegmentSegment(Point const & p1, Point const & q1, Point const & p2, Point const & q2, Point & c1, Point & c2);
6214  bool IsPlane(Exchange::Component const & face_component);
6215  Point GetPlaneIntersection(Plane const & in_plane, KeyPath const & in_key_path, WindowPoint const & in_window_point);
6216  };
6217 
6218 private:
6220  Exchange();
6221 };
6222 
6223 }
6224 
6225 #endif
HPS::WindowPoint
Definition: hps.h:6418
HPS
Definition: hps.h:85
HPS::Exchange::ExportPRCOptionsKit
Definition: sprk_exchange.h:4275
HPS::Exchange::Tessellation::Level
Level
Definition: sprk_exchange.h:917
HPS::Exchange::ProE::ConstructionEntities
ConstructionEntities
Definition: sprk_exchange.h:1080
HPS::Exchange
Definition: sprk_exchange.h:44
HPS::Exchange::PRC
Definition: sprk_exchange.h:1031
HPS::View
Definition: sprk.h:1103
HPS::Exchange::ExportSTEPOptionsKit::ObjectType
HPS::Type ObjectType() const
Definition: sprk_exchange.h:5274
HPS::Exchange::File
Definition: sprk_exchange.h:1214
HPS::Exchange::CommonMeasurementOperator
Definition: sprk_exchange.h:5745
HPS::Exchange::ExportOBJOptionsKit::ObjectType
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4632
HPS::Exchange::ExportIGESOptionsKit::ObjectType
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4935
HPS::InvalidSpecificationException
An InvalidSpecificationException is thrown when a method is called with non-sensical or contradictory...
Definition: hps.h:6022
HPS::Exchange::Units
Units
Definition: sprk_exchange.h:65
HPS::Sprocket
Definition: sprk.h:68
HPS::Exchange::Translation::Simplification
Simplification
Definition: sprk_exchange.h:3174
HPS::Canvas
Definition: sprk.h:936
HPS::Exchange::CommonMeasurementOperator::GetName
virtual HPS::UTF8 GetName() const override
Definition: sprk_exchange.h:5764
HPS::Exchange::TranslationNotifier
Definition: sprk_exchange.h:656
HPS::Exchange::U3D::Version
Version
Definition: sprk_exchange.h:1101
HPS::Exchange::ModelFileImportOptionsKit
Definition: sprk_exchange.h:3463
HPS::Exchange::Tessellation::Chord
Definition: sprk_exchange.h:927
HPS::Event::GetChannel
intptr_t GetChannel() const
Definition: hps.h:6535
HPS::Exchange::ReloadNotifier
Definition: sprk_exchange.h:757
HPS::Exchange::SurfaceType
SurfaceType
Definition: sprk_exchange.h:849
HPS::Line
Definition: hps.h:1766
HPS::Exchange::STEP::Format
Format
Definition: sprk_exchange.h:1018
HPS::Exchange::ExportXMLOptionsKit
Definition: sprk_exchange.h:4798
HPS::SprocketKit
Definition: sprk.h:1072
HPS::Exchange::TessellationOptionsKit::ObjectType
HPS::Type ObjectType() const
Definition: sprk_exchange.h:5611
HPS::KeyPathArray
std::vector< KeyPath, Allocator< KeyPath > > KeyPathArray
Array of type HPS::KeyPath.
Definition: hps.h:6884
HPS::ByteArray
std::vector< byte, Allocator< byte > > ByteArray
Array of type HPS::byte.
Definition: hps.h:6860
HPS::KeyboardState
Definition: hps.h:49119
HPS::Exchange::File::Format
Format
Definition: sprk_exchange.h:1219
HPS::SegmentKey
Definition: hps.h:7929
HPS::BoolArray
std::vector< bool, Allocator< bool > > BoolArray
Array of type bool.
Definition: hps.h:6854
HPS::Exchange::Tessellation::Type
Type
Definition: sprk_exchange.h:908
HPS::Exchange::Export3MFOptionsKit::ObjectType
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3804
HPS::MaterialMappingKit
Definition: hps.h:16646
HPS::Exchange::Configuration::ObjectType
HPS::Type ObjectType() const
Definition: sprk_exchange.h:1168
HPS::Exchange::Filter
Definition: sprk_exchange.h:504
HPS::Exchange::ImportNotifier
Definition: sprk_exchange.h:595
HPS::Exchange::CADModel
Definition: sprk_exchange.h:334
HPS::Exchange::NURBSConversionOptionsKit::ObjectType
HPS::Type ObjectType() const
Definition: sprk_exchange.h:1510
HPS::Exchange::Filter::ObjectType
HPS::Type ObjectType() const
Definition: sprk_exchange.h:531
HPS::Exchange::ExportXMLOptionsKit::ObjectType
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4815
HPS::Exchange::ExportU3DOptionsKit::ObjectType
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4714
HPS::Exchange::ExportFBXOptionsKit::ObjectType
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3951
HPS::Exchange::ProductOccurrence::ObjectType
HPS::Type ObjectType() const
Definition: sprk_exchange.h:236
HPS::Exchange::ReloadNotifier::ObjectType
HPS::Type ObjectType() const
Definition: sprk_exchange.h:786
HPS::Exchange::CommonMeasurementOperator::MeasurementInsertedEvent::MeasurementInsertedEvent
MeasurementInsertedEvent(Event const &in_event)
Definition: sprk_exchange.h:5822
HPS::Exchange::ExportGLTFOptionsKit
Definition: sprk_exchange.h:5488
HPS::Exchange::NURBSConversionOptionsKit
Definition: sprk_exchange.h:1487
HPS::Exchange::Sheet
Definition: sprk_exchange.h:274
HPS::Exchange::ImportNotifier::ObjectType
HPS::Type ObjectType() const
Definition: sprk_exchange.h:624
HPS::Exchange::ExportJTOptionsKit
Definition: sprk_exchange.h:4141
HPS::Exchange::Translation::Merging
Merging
Definition: sprk_exchange.h:3183
HPS::Exchange::Revit
Definition: sprk_exchange.h:1113
HPS::Exchange::STEP::Field
Field
Definition: sprk_exchange.h:1008
HPS::Exchange::ExportOBJOptionsKit
Definition: sprk_exchange.h:4615
HPS::TouchState
Definition: hps.h:49017
HPS::GlyphDefinition
Definition: hps.h:42386
HPS::Exchange::ExportACISOptionsKit
Definition: sprk_exchange.h:4039
HPS::Exchange::TranslationOptionsKit
Definition: sprk_exchange.h:3196
HPS::Point_3D< float >
HPS::Exchange::CommonMeasurementOperator::MeasurementDeletedEvent::Clone
Event * Clone() const
Definition: sprk_exchange.h:5884
HPS::Exchange::Tessellation::Chord::Limit
Limit
Definition: sprk_exchange.h:932
HPS::RGBAColor
Definition: hps.h:4607
HPS::Exchange::ModelFileImportOptionsKit::ObjectType
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3486
HPS::Exchange::JT::TessellationLevel
TessellationLevel
Definition: sprk_exchange.h:981
HPS::Exchange::Tessellation
Definition: sprk_exchange.h:903
HPS::Exchange::ExportSTLOptionsKit
Definition: sprk_exchange.h:4432
HPS::Exchange::Component
Definition: sprk_exchange.h:113
HPS::Exchange::ExportGLTFOptionsKit::ObjectType
HPS::Type ObjectType() const
Definition: sprk_exchange.h:5505
HPS::Exchange::STEP
Definition: sprk_exchange.h:1003
HPS::Exchange::ExportFBXOptionsKit
Definition: sprk_exchange.h:3934
HPS::RGBColor
Definition: hps.h:4546
HPS::UTF8
Definition: hps.h:7300
HPS::MouseButtons
Definition: hps.h:48488
HPS::Exchange::ExportACISOptionsKit::ObjectType
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4056
HPS::Exchange::Capture
Definition: sprk_exchange.h:455
HPS::Exchange::UnloadMode
UnloadMode
Definition: sprk_exchange.h:82
HPS::SelectionOptionsKit
Definition: hps.h:44399
HPS::MouseState
Definition: hps.h:48904
HPS::DWG
Definition: sprk_dwg.h:43
HPS::Exchange::AnnotationCaptureFitting
AnnotationCaptureFitting
Definition: sprk_exchange.h:896
HPS::Exchange::ExportU3DOptionsKit
Definition: sprk_exchange.h:4697
HPS::Exchange::JT
Definition: sprk_exchange.h:967
HPS::MatrixKit
Definition: hps.h:16019
HPS::IntArray
std::vector< int, Allocator< int > > IntArray
Array of type int.
Definition: hps.h:6840
HPS::Exchange::U3D
Definition: sprk_exchange.h:1096
HPS::Exchange::ProE::SessionColor
SessionColor
Definition: sprk_exchange.h:1055
HPS::Component
Definition: sprk.h:2622
HPS::IONotifier
Definition: hps.h:49226
HPS::Exchange::LoadStatus
LoadStatus
Definition: sprk_exchange.h:97
HPS::HighlightOptionsKit
Definition: hps.h:45606
HPS::ModifierKeys
Definition: hps.h:47995
HPS::Exchange::CurveType
CurveType
Definition: sprk_exchange.h:872
HPS::Exchange::Factory
Definition: sprk_exchange.h:549
HPS::Event
Definition: hps.h:6502
HPS::TextAttributeKit
Definition: hps.h:14267
HPS::Vector_3D< float >
HPS::UTF8Array
std::vector< UTF8, Allocator< UTF8 > > UTF8Array
Array of type HPS::UTF8.
Definition: hps.h:6852
HPS::Exchange::MeasurementOperator
Definition: sprk_exchange.h:5979
HPS::Model
Definition: sprk.h:1318
HPS::Exchange::PRC::BRepCompression
BRepCompression
Definition: sprk_exchange.h:1036
HPS::Exchange::ExportParasolidOptionsKit::ObjectType
HPS::Type ObjectType() const
Definition: sprk_exchange.h:5113
HPS::Parasolid
Definition: sprk_parasolid.h:39
HPS::Exchange::BRepMode
BRepMode
Definition: sprk_exchange.h:822
HPS::ComponentPath
Definition: sprk.h:2994
HPS::Component::ComponentType
ComponentType
Definition: sprk.h:2628
HPS::Exchange::Tessellation::Accuracy
Accuracy
Definition: sprk_exchange.h:949
HPS::Exchange::Export3MFOptionsKit
Definition: sprk_exchange.h:3787
HPS::Exchange::ExportIGESOptionsKit
Definition: sprk_exchange.h:4918
HPS::Exchange::CommonMeasurementOperator::MeasurementDeletedEvent::MeasurementDeletedEvent
MeasurementDeletedEvent(Event const &in_event)
Definition: sprk_exchange.h:5868
HPS::Filter
Definition: sprk.h:3700
HPS::Exchange::ProE::FamilyTable
FamilyTable
Definition: sprk_exchange.h:1068
HPS::Exchange::ExportSTLOptionsKit::ObjectType
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4449
HPS::Exchange::JT::Content
Content
Definition: sprk_exchange.h:972
HPS::Exchange::ImportOptionsKit
Definition: sprk_exchange.h:1712
HPS::Capture
Definition: sprk.h:3800
HPS::Exchange::ExportJTOptionsKit::ObjectType
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4158
HPS::MouseButtons::ButtonLeft
static MouseButtons ButtonLeft()
Definition: hps.h:48606
HPS::Exchange::MeasurementOperator::GetName
virtual HPS::UTF8 GetName() const override
Definition: sprk_exchange.h:5995
HPS::Exchange::CommonMeasurementOperator::MeasurementInsertedEvent::Clone
Event * Clone() const
Definition: sprk_exchange.h:5838
HPS::Key
Definition: hps.h:7847
HPS::Exchange::TranslationNotifier::ObjectType
HPS::Type ObjectType() const
Definition: sprk_exchange.h:685
HPS::Exchange::ProE
Definition: sprk_exchange.h:1050
HPS::Exchange::Translation::AccurateEdges
AccurateEdges
Definition: sprk_exchange.h:3165
HPS::Exchange::CADModel::ObjectType
HPS::Type ObjectType() const
Definition: sprk_exchange.h:361
HPS::Exchange::Component::ObjectType
HPS::Type ObjectType() const
Definition: sprk_exchange.h:135
HPS::KeyPath
Definition: hps.h:9560
HPS::Exchange::ExportNotifier::ObjectType
HPS::Type ObjectType() const
Definition: sprk_exchange.h:739
HPS::Exchange::ExportNotifier
Definition: sprk_exchange.h:710
HPS::LineKey
Definition: hps.h:24926
HPS::Exchange::Translation::Healing
Healing
Definition: sprk_exchange.h:3156
HPS::CADModel
Definition: sprk.h:3887
HPS::TextKey
Definition: hps.h:31359
HPS::Exchange::Revit::PhysicalProperties
PhysicalProperties
Definition: sprk_exchange.h:1116
HPS::Exchange::Sheet::ObjectType
HPS::Type ObjectType() const
Definition: sprk_exchange.h:307
HPS::Exchange::ImportMode
ImportMode
Definition: sprk_exchange.h:837
HPS::Exchange::Configuration
Definition: sprk_exchange.h:1130
HPS::Cylinder
Definition: hps.h:514
HPS::Operator
Definition: sprk.h:1946
HPS::Exchange::Translation
Definition: sprk_exchange.h:3151
HPS::Exchange::Capture::ObjectType
HPS::Type ObjectType() const
Definition: sprk_exchange.h:482
HPS::Plane_3D< float >
HPS::Factory::CreateModel
static Model CreateModel(char const *in_name="")
HPS::Exchange::ExportParasolidOptionsKit
Definition: sprk_exchange.h:5096
HPS::Exchange::ImportOptionsKit::ObjectType
HPS::Type ObjectType() const
Definition: sprk_exchange.h:1735
HPS::Exchange::ProductOccurrence
Definition: sprk_exchange.h:203
HPS::Exchange::TranslationOptionsKit::ObjectType
HPS::Type ObjectType() const
Definition: sprk_exchange.h:3219
HPS::PortfolioKey
Definition: hps.h:41882
HPS::Exchange::JT::Version
Version
Definition: sprk_exchange.h:990
HPS::Exchange::TessellationOptionsKit
Definition: sprk_exchange.h:5594
HPS::Exchange::ExportPRCOptionsKit::ObjectType
HPS::Type ObjectType() const
Definition: sprk_exchange.h:4292
HPS::ImageKit
Definition: hps.h:43017
HPS::Exchange::ExportSTEPOptionsKit
Definition: sprk_exchange.h:5257