hps.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 HPS_H
11 #define HPS_H
12 
13 #ifdef _MSC_VER
14 # ifndef STATIC_APP
15 # ifdef HPS_CORE_BUILD
16 # define HPS_API __declspec (dllexport)
17 # define EXPIMP_TEMPLATE
18 # else
19 # define HPS_API __declspec (dllimport)
20 # define EXPIMP_TEMPLATE extern
21 # endif
22 # define HPS_TEMPLATE_API __declspec (dllexport)
23 # endif
24 # ifdef _WINDOWS_
25 # undef Ellipse
26 # undef Polyline
27 # undef Polygon
28 # undef Rectangle
29 # undef min
30 # undef max
31 # endif
32 # pragma warning(push)
33 # pragma warning(disable: 4251) //Not an issue as long as debug and release libraries aren't mixed
34 #else
35 # include <limits.h>
36 # include <stddef.h>
37 # ifdef LINUX_SYSTEM
38 # ifndef STATIC_APP
39 # ifdef HPS_CORE_BUILD
40 # define HPS_API __attribute__ ((visibility ("default")))
41 # define EXPIMP_TEMPLATE
42 # else
43 # define EXPIMP_TEMPLATE extern
44 # endif
45 # define HPS_TEMPLATE_API __attribute__ ((visibility ("default")))
46 # endif
47 # endif
48 #endif
49 #ifndef HPS_API
50 # define HPS_API
51 #endif
52 #ifndef HPS_TEMPLATE_API
53 # define HPS_TEMPLATE_API
54 #endif
55 #ifndef EXPIMP_TEMPLATE
56 # define EXPIMP_TEMPLATE
57 #endif
58 #ifndef ENUM_CLASS
59 # define ENUM_CLASS enum class
60 #endif
61 
62 #define NO_HPS_API
63 
64 #include <stdint.h>
65 #include <memory>
66 #include <vector>
67 #include <math.h>
68 #include <float.h>
69 #include <limits>
70 #include <stdexcept>
71 #include <algorithm>
72 #include <cstring>
73 
74 
75 # if !defined(__APPLE__) && defined(__GNUC__) && (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 8))
76 # define OLD_GCC
77 # define OVERRIDE
78 # else
79 # define OVERRIDE override
80 # endif
81 
82 namespace HPSI
83 {
84  class Impl;
85  class KeyImpl;
86  class TicketImpl;
87  class EventDispatcherImpl;
88  class AbstractImage;
89 };
90 
91 namespace HPS
92 {
93 
94  // unimplemented
95 
96 
97 //Begin Info
99 class HPS_API Info
100 {
101 public:
104  enum class Code {
105  Unknown,
106  Exchange,
107  Publish,
108  Data,
109  Key,
110  Geometry,
111  Database,
112  Driver,
113  Internal,
114  Memory,
115  System,
116  Unsupported,
117  DX9DeviceReset,
118  DWG,
119  };
120 
121 private:
123  Info();
124 };
125 
126 
127 //Begin Info
129 class HPS_API Emergency
130 {
131 public:
134  enum class Code {
135  Unknown,
136  Fatal,
137  SoftMemoryLimit,
138  HardMemoryLimit,
139  };
140 
141 private:
143  Emergency();
144 };
145 
146 
147 //Begin Window
149 class HPS_API Window
150 {
151 public:
154  enum class Driver {
155  Default3D,
156  OpenGL,
157  OpenGL2,
158  DirectX9,
159  DirectX11,
160  };
161 
164  enum class UpdateStatus {
165  InProgress,
166  Completed,
167  TimedOut,
168  Interrupted,
169  Failed
170  };
171 
175  enum class UpdateControl {
176  DefaultUpdate,
177 
180  CompleteUpdate,
181 
182  RefreshUpdate,
183 
184  CompileOnlyUpdate,
185 
189  ExhaustiveUpdate,
190  };
191 
194  enum class Mobility
195  {
196  Locked,
197  Floating,
198  FixedRatio,
199  Free
200  };
201 
205  enum class FrameSize
206  {
207  Single,
208  Double
209  };
210 
214  enum class FrameOptions
215  {
216  Inset,
217  Overlay
218  };
219 
220  enum class ImageFormat
221  {
222  Default,
223  RGBA,
224  RGB,
225  Jpeg,
226  Png
227  };
228 
229 private:
231  Window();
232 };
233 
234 //Begin Subwindow
236 class HPS_API Subwindow
237 {
238 public:
239  enum class Background
240  {
241  SolidColor,
242  Image,
243  Cubemap,
244  Blend,
245  Transparent,
246  Interactive,
247 
248  GradientTopToBottom,
249  GradientBottomToTop,
250  GradientLeftToRight,
251  GradientRightToLeft,
252  GradientTopLeftToBottomRight,
253  GradientTopRightToBottomLeft,
254  GradientBottomLeftToTopRight,
255  GradientBottomRightToTopLeft,
256  };
257 
258  enum class Type
259  {
260  Standard,
261  Lightweight
262  };
263 
264  enum class Border
265  {
266  None,
267  Inset,
268  InsetBold,
269  Overlay,
270  OverlayBold
271  };
272 
273 
276  {
279  ZBuffer,
280 
286  HiddenLine,
287 
293  FastHiddenLine,
294 
307  Priority
308  };
309 
310 private:
311  Subwindow();
312 };
313 //End Subwindow
314 
316 class HPS_API Style
317 {
318 public:
319 
323  enum class Type
324  {
325  Segment,
326  Named
327  };
328 
332  enum class AppendMode
333  {
334  None,
335  And,
336  Or
337  };
338 
339 private:
340  Style();
341 };
342 
343 
344 //Begin Shell Attributes
346 class HPS_API Shell
347 {
348 public:
349 
352  enum class Component
353  {
354  Faces,
355  Edges,
356  Vertices
357  };
358 
359  /* \enum ToleranceUnits
360  * Enumerates the Tolerance Units used to determine if points can be merged during shell optimization. */
361  enum class ToleranceUnits
362  {
363  ObjectSpace,
364  FeatureSizePercentage
365  };
366 
367  /* \enum HandednessOptimization
368  * Enumerates the shell optimization options with regards to handedness. */
370  {
371  None,
372  FixHandedness,
373  ReverseHandedness
374  };
375 
376  /* \enum RelationResults
377  * Enumerates the results of a shell relation computation. */
378  enum class Relation
379  {
380  On,
381  Off,
382  In,
383  Out
384  };
385 
386  /* \enum RelationTest
387  * Enumerates the test options for a shell relation computation. */
388  enum class RelationTest
389  {
390  Simple,
391  Enclosure,
392  Distance
393  };
394 
395 private:
397  Shell();
398 };
399 //End Shell Attributes
400 
401 //Begin Mesh Attributes
403 class HPS_API Mesh
404 {
405 public:
408  enum class Component
409  {
410  Faces,
411  Edges,
412  Vertices
413  };
414 
415 private:
417  Mesh();
418 };
419 //End Mesh Attributes
420 
421 //Begin InfiniteLine Attributes
423 class HPS_API InfiniteLine
424 {
425 public:
428  enum class Type
429  {
430  Line,
431  Ray
432  };
433 
434 private:
436  InfiniteLine();
437 };
438 //End InfiniteLine Attributes
439 
441 class HPS_API Trim
442 {
443 public:
446  enum class Type
447  {
448  Line,
449  Curve
450  };
451 
455  enum class Operation
456  {
457  Keep,
458  Remove
459  };
460 private:
462  Trim();
463 };
464 
465 //Begin Spotlight Attributes
467 class HPS_API Spotlight
468 {
469 public:
472  enum class OuterConeUnits
473  {
477  Degrees,
481  FieldRadius
482  };
483 
486  enum class InnerConeUnits
487  {
491  Degrees,
495  FieldRadius,
498  Percent
499  };
500 
501 
502 private:
504  Spotlight();
505 };
506 //End Spotlight Attributes
507 
508 
509 
510 
511 //Begin Cylinder Attributes
513 class HPS_API Cylinder
514 {
515 public:
518  enum class Component
519  {
520  Faces,
521  Edges,
522  };
523 
526  enum class Capping
527  {
528  None,
529  First,
530  Last,
531  Both
532  };
533 
537  enum class Orientation
538  {
539  Default,
540  DefaultRadii,
541  InvertRadii,
542  InvertRadiiOnly,
543  DefaultColors,
544  InvertColors,
545  InvertColorsOnly,
546  InvertAll
547  };
548 
549 private:
551  Cylinder();
552 };
553 
554 
556 class HPS_API Search
557 {
558 public:
561  enum class Space
562  {
563  SegmentOnly,
564  Subsegments,
565  SubsegmentsAndIncludes
566  };
567 
570  enum class Behavior
571  {
572  Exhaustive,
573  FirstMatch
574  };
575 
576 
577  // IMPORTANT: Remember to add compile time asserts in hpsi.cpp to keep these synchronized to 3DF HK types (if they map to HK types)
581  enum class Type : uint32_t {
582 
583  /* This enum classeration is divided into three parts.
584 
585  0xAABBBCCC
586 
587  The bits in A encode the most general category of the type (Geometry, Attribute).
588  The bits in B encode the subtype (Culling, TextAttribute). Attributes alone have these so far.
589  The bits in C encode the specific type (Shell, CullingVectorTolerance, TextAttributeSpacing).
590 
591  General category designators should have no bits in B or C.
592  Subtype category designators should have bits in A and B but not C.
593  Specific category designators should have bits in A and C and optionally B.
594 
595  Some types map to an HK type. To get the HK type you should mask out its subtype if it has one, else mask out its general type.
596  These types are kept in sync with the 3DF HK types by using Compile-time assets in hpsi.cpp.
597 
598  Geometry have no subtype. Most, 'Ordinary Geometry' map to a 3DF HK type.
599  The mutants or 'Special Geometry' (some lights and infinite ray) have no HK type to map to.
600 
601  Attributes come in a few forms.
602  The 'Simple Attributes' map to an HK type and have no subtypes -- they are what they are. ModellingMatrix, Camera, etc.
603  The 'Complex Attributes' have subtypes. A handful map to an HK type, but the majority are not.
604  */
605  None = 0x00000000,
606  Everything = 0x00ffffff,
607 
608  // Segment Stuff (Include & Segment map to HK types)
609  Include = 0x00000042,
610  Segment = 0x00000043,
611 
612  Includer = 0x00000100,
613 
614  // Geometry
615  Geometry = 0x10000000,
616 
617  // Ordinary Geometry (map to HK types) - (HK_* | Geometry)
618  CuttingSection = 0x10000026,
619  Shell = 0x10000028,
620  Mesh = 0x10000029,
621  Grid = 0x1000002a,
622  NURBSSurface = 0x1000002b,
623  Cylinder = 0x1000002d,
624  Sphere = 0x1000002e,
625  Polygon = 0x1000002f,
626  Circle = 0x10000030,
627  //unused = 0x10000031,
628  CircularWedge = 0x10000032,
629  Ellipse = 0x10000033,
630  Line = 0x10000034,
631  NURBSCurve = 0x10000037,
632  CircularArc = 0x10000038,
633  EllipticalArc = 0x10000039,
634  InfiniteLine = 0x1000003a,
635 // Image = 0x1000003b, N/A since images live in portfolios
636  Marker = 0x1000003c,
637  Text = 0x1000003e,
638  Reference = 0x10000040,
639 
640  // Special Geometry
641  DistantLight = 0x10000100,
642  Spotlight = 0x10000101,
643  InfiniteRay = 0x10000102,
644 
645  // Attributes
646  Attribute = 0x20000000,
647 
648  Priority = 0x20000001,
649 
650  // Simple Attributes (map to HK types)
651  Material = 0x2000000a,
652  Camera = 0x2000000e,
653  ModellingMatrix = 0x20000010,
654  UserData = 0x20000021,
655  TextureMatrix = 0x20000023,
656 
657  // Complex Attributes
658  Culling = 0x20001000,
659  CullingBackFace = 0x20001001,
660  CullingExtent = 0x20001002,
661  CullingVector = 0x20001003,
662  CullingVectorTolerance = 0x20001004,
663  CullingFrustum = 0x20001005,
664  CullingDeferralExtent = 0x20001006,
665 
666  CurveAttribute = 0x20002000,
667  CurveAttributeBudget = 0x20002001,
668  CurveAttributeContinuedBudget = 0x20002002,
669  CurveAttributeViewDependent = 0x20002003,
670  CurveAttributeMaximumDeviation = 0x20002004,
671  CurveAttributeMaximumAngle = 0x20002005,
672  CurveAttributeMaximumLength = 0x20002006,
673 
674  CylinderAttribute = 0x20003000,
675  CylinderAttributeTessellation = 0x20003001,
676  CylinderAttributeOrientation = 0x20003002,
677 
678  // EdgeAttributes map to HK types
679  EdgeAttribute = 0x20004000,
680  EdgeAttributePattern = 0x20004015,
681  EdgeAttributeWeight = 0x20004016,
682 
683  LightingAttribute = 0x20005000,
684  LightingAttributeInterpolation = 0x20005001,
685 
686  // LineAttributes map to HK types
687  LineAttribute = 0x20006000,
688  LineAttributePattern = 0x20006019,
689  LineAttributeWeight = 0x2000601a,
690 
691  // MarkerAttributes map to HK types
692  MarkerAttribute = 0x20007000,
693  MarkerAttributeSize = 0x2000701b,
694  MarkerAttributeSymbol = 0x2000701c,
695 
696  SurfaceAttribute = 0x20008000,
697  SurfaceAttributeBudget = 0x20008001,
698  SurfaceAttributeMaximumFacetDeviation = 0x20008002,
699  SurfaceAttributeMaximumFacetAngle = 0x20008003,
700  SurfaceAttributeMaximumFacetWidth = 0x20008004,
701  SurfaceAttributeTrimCurveBudget = 0x20008005,
702  SurfaceAttributeMaximumTrimCurveDeviation = 0x20008006,
703 
704  Selectability = 0x20009000,
705  SelectabilityWindows = 0x20009001,
706  SelectabilityEdges = 0x20009002,
707  SelectabilityFaces = 0x20009003,
708  SelectabilityLights = 0x20009004,
709  SelectabilityLines = 0x20009005,
710  SelectabilityMarkers = 0x20009006,
711  SelectabilityVertices = 0x20009007,
712  SelectabilityText = 0x20009008,
713 
714  SphereAttribute = 0x2000a000,
715  SphereAttributeTessellation = 0x2000a001,
716 
717  Subwindow = 0x2000b000,
718  SubwindowEitherType = 0x2000b001,
719  SubwindowStandard = 0x2000b00d,
720  SubwindowLightweight = 0x2000b002,
721  SubwindowBackground = 0x2000b003,
722  SubwindowBorder = 0x2000b004,
723  SubwindowRenderingAlgorithm = 0x2000b005,
724 
725  // TextAttributeAlignment, Path, & Spacing map to HK types
726  TextAttribute = 0x2000c000,
727  TextAttributeAlignment = 0x2000c01d,
728  TextAttributeBold = 0x2000c002,
729  TextAttributeItalic = 0x2000c003,
730  TextAttributeOverline = 0x2000c004,
731  TextAttributeStrikethrough = 0x2000c005,
732  TextAttributeUnderline = 0x2000c006,
733  TextAttributeSlant = 0x2000c007,
734  TextAttributeLineSpacing = 0x2000c008,
735  TextAttributeRotation = 0x2000c00a,
736  TextAttributeExtraSpace = 0x2000c00b,
737  TextAttributeGreeking = 0x2000c00c,
738  TextAttributeSizeTolerance = 0x2000c00d,
739  TextAttributeSize = 0x2000c00e,
740  TextAttributeFont = 0x2000c00f,
741  TextAttributeTransform = 0x2000c010,
742  TextAttributeRenderer = 0x2000c011,
743  TextAttributePreference = 0x2000c012,
744  TextAttributePath = 0x2000c01f,
745  TextAttributeSpacing = 0x2000c020,
746 
747  Transparency = 0x2000d000,
748  TransparencyMethod = 0x2000d001,
749  TransparencyAlgorithm = 0x2000d002,
750  TransparencyDepthPeelingLayers = 0x2000d004,
751  TransparencyDepthPeelingMinimumArea = 0x2000d005,
752  TransparencyDepthWriting = 0x2000d006,
753 
754  Visibility = 0x2000e000,
755  VisibilityCuttingSections = 0x2000e001,
756  VisibilityCutEdges = 0x2000e002,
757  VisibilityCutFaces = 0x2000e003,
758  VisibilityWindows = 0x2000e004,
759  VisibilityText = 0x2000e005,
760  VisibilityLines = 0x2000e006,
761  VisibilityEdgeLights = 0x2000e007,
762  VisibilityMarkerLights = 0x2000e008,
763  VisibilityFaceLights = 0x2000e009,
764  VisibilityGenericEdges = 0x2000e00a,
765  VisibilityHardEdges = 0x2000e00b,
766  VisibilityAdjacentEdges = 0x2000e00c,
767  VisibilityInteriorSilhouetteEdges = 0x2000e00d,
768  VisibilityShadowEmitting = 0x2000e00e,
769  VisibilityShadowReceiving = 0x2000e00f,
770  VisibilityShadowCasting = 0x2000e010,
771  VisibilityMarkers = 0x2000e011,
772  VisibilityVertices = 0x2000e012,
773  VisibilityFaces = 0x2000e013,
774  VisibilityPerimeterEdges = 0x2000e014,
775  VisibilityNonCulledEdges = 0x2000e015,
776  VisibilityMeshQuadEdges = 0x2000e016,
777 
778  VisualEffects = 0x2000f000,
779  VisualEffectsPostProcessEffectsEnabled = 0x2000f001,
780  VisualEffectsAntiAliasing = 0x2000f002,
781  VisualEffectsShadowMaps = 0x2000f003,
782  VisualEffectsSimpleShadow = 0x2000f004,
783  VisualEffectsSimpleShadowPlane = 0x2000f005,
784  VisualEffectsSimpleShadowLightDirection = 0x2000f006,
785  VisualEffectsSimpleShadowColor = 0x2000f007,
786  VisualEffectsSimpleReflection = 0x2000f008,
787  VisualEffectsSimpleReflectionPlane = 0x2000f009,
788  VisualEffectsSimpleReflectionVisibility = 0x2000f00a,
789 
790  Performance = 0x20010000,
791  PerformanceDisplayLists = 0x20010001,
792  PerformanceStaticModel = 0x20010002,
793  StaticModelSegment = 0x40000043,
794 
795  // DrawingAttributeWorldHandedness map to HK types
796  DrawingAttribute = 0x20011000,
797  DrawingAttributePolygonHandedness = 0x20011001,
798  DrawingAttributeDepthRange = 0x20011002,
799  DrawingAttributeFaceDisplacement = 0x20011003,
800  DrawingAttributeGeneralDisplacement = 0x20011004,
801  DrawingAttributeVertexDisplacement = 0x20011005,
802  DrawingAttributeOverlay = 0x20011006,
803  DrawingAttributeDeferral = 0x20011007,
804  DrawingAttributeClipRegion = 0x20011012,
805  DrawingAttributeWorldHandedness = 0x20011018,
806 
807  HiddenLineAttribute = 0x20012000,
808  HiddenLineAttributeColor = 0x20012001,
809  HiddenLineAttributeDimFactor = 0x20012002,
810  HiddenLineAttributeFaceDisplacement = 0x20012003,
811  HiddenLineAttributeLinePattern = 0x20012005,
812  HiddenLineAttributeRenderFaces = 0x20012006,
813  HiddenLineAttributeRenderText = 0x20012007,
814  HiddenLineAttributeAlgorithm = 0x20012008,
815  HiddenLineAttributeSilhouetteCleanup = 0x20012009,
816  HiddenLineAttributeVisibility = 0x2001200a,
817  HiddenLineAttributeWeight = 0x2001200b,
818  HiddenLineAttributeTransparencyCutoff = 0x2001200c,
819 
820  SegmentStyle = 0x20013001,
821  NamedStyle = 0x20013002,
822  MaterialPalette = 0x20013003,
823  Portfolio = 0x20013004,
824 
825  ContourLine = 0x20014000,
826  ContourLineVisibility = 0x20014001,
827  ContourLinePosition = 0x20014002,
828  ContourLineColor = 0x20014003,
829  ContourLinePattern = 0x20014004,
830  ContourLineWeight = 0x20014005,
831  ContourLineLighting = 0x20014006,
832 
833  Condition = 0x20015000,
834 
835  Bounding = 0x20016000,
836  BoundingVolume = 0x20016001,
837  BoundingExclusion = 0x20016002,
838 
839  AttributeLock = 0x20017000,
840  AttributeLockSetting = 0x20017001,
841  AttributeLockSubsegmentOverride = 0x20017002,
842 
843  TransformMask = 0x20018000,
844  TransformMaskCamera = 0x20018001,
845  TransformMaskCameraTranslation = 0x20018002,
846  TransformMaskCameraScale = 0x20018003,
847  TransformMaskCameraOffset = 0x20018004,
848  TransformMaskCameraRotation = 0x20018005,
849  TransformMaskCameraPerspectiveScale = 0x20018006,
850  TransformMaskCameraProjection = 0x20018007,
851  TransformMaskModellingMatrix = 0x20018008,
852  TransformMaskModellingMatrixTranslation = 0x20018009,
853  TransformMaskModellingMatrixScale = 0x20018010,
854  TransformMaskModellingMatrixOffset = 0x20018011,
855  TransformMaskModellingMatrixRotation = 0x20018012,
856 
857  ColorInterpolation = 0x20019000,
858  ColorInterpolationFaceColor = 0x20019001,
859  ColorInterpolationEdgeColor = 0x20019002,
860  ColorInterpolationMarkerColor = 0x20019003,
861  ColorInterpolationFaceIndex = 0x20019004,
862  ColorInterpolationEdgeIndex = 0x20019005,
863  ColorInterpolationMarkerIndex = 0x20019006,
864 
865  CuttingSectionAttribute = 0x2001a000,
866  CuttingSectionAttributeCuttingLevel = 0x2001a001,
867  CuttingSectionAttributeCappingLevel = 0x2001a002,
868  CuttingSectionAttributeMaterialPreference = 0x2001a003,
869 
870  };
871  // IMPORTANT: Remember to add compile time asserts in hpsi.cpp to keep these synchronized to HK types (if they are map to HK types)
872 
873 private:
875  Search();
876 };
877 
879 class HPS_API Material
880 {
881 public:
884  enum class Type
885  {
886  InvalidMaterialIndex = -1,
887  Nothing = 0,
888  FullMaterial,
889  ExplicitRGBColor,
890  ExplicitRGBAColor,
891  MaterialIndex,
892  TextureName,
893  ModulatedTexture,
894  CubeMapName,
895  ModulatedCubeMap,
896  GlossValue,
897  DiffuseChannelAlpha
898 
899  };
900 
904  enum class Channel
905  {
906  DiffuseColor = 1,
907  DiffuseTexture = 2,
908  Specular = 3,
909  Emission = 4,
910  Transmission = 5,
911  Mirror = 6,
912  Bump = 7,
913  EnvironmentTexture = 8,
914  EnvironmentCubeMap = 9,
915  Gloss = 10
916  };
917 
919  class HPS_API Color
920  {
921  public:
925  enum class Channel
926  {
927  DiffuseColor = 1,
928  Specular = 3,
929  Emission = 4,
930  Mirror = 6
931  };
932 
933  private:
935  Color();
936  };
937 
939  class HPS_API Texture
940  {
941  public:
945  enum class Channel
946  {
947  DiffuseTexture = 2,
948  Specular = 3,
949  Emission = 4,
950  Transmission = 5,
951  Mirror = 6,
952  Bump = 7,
953  EnvironmentTexture = 8,
954  EnvironmentCubeMap = 9
955  };
956 
959  enum class Parameterization
960  {
962  Cylinder,
964  PhysicalReflection,
966  Object,
972  NaturalUV,
974  ReflectionVector,
976  SurfaceNormal,
978  Sphere,
980  UV,
982  World
983  };
984 
987  enum class Tiling
988  {
991  Clamp,
993  Repeat,
995  Reflect,
998  Trim
999  };
1000 
1003  enum class Interpolation
1004  {
1006  Bilinear,
1007 
1009  InterpolationOff
1010  };
1011 
1014  enum class Decimation
1015  {
1018  Anisotropic,
1020  Mipmap,
1022  DecimationOff
1023  };
1024 
1028  enum class ChannelMapping
1029  {
1030  Red,
1031  Green,
1032  Blue,
1033  Alpha,
1034  Zero,
1035  One,
1036  Luminance
1037  };
1038 
1039  private:
1041  Texture();
1042  };
1043 private:
1045  Material();
1046 };
1047 
1048 class HPS_API PostProcessEffects
1049 {
1050 public:
1051  class HPS_API AmbientOcclusion
1052  {
1053  public:
1057  enum class Quality
1058  {
1059  Fastest,
1060  Nicest
1061  };
1062 
1063  private:
1064  AmbientOcclusion();
1065  };
1066 
1067  class HPS_API Bloom
1068  {
1069  public:
1073  enum class Shape
1074  {
1075  Star,
1076  Radial
1077  };
1078 
1079  private:
1080  Bloom();
1081  };
1082 
1083 private:
1084  PostProcessEffects() {}
1085 };
1086 
1087 class HPS_API Performance
1088 {
1089 public:
1093  enum class DisplayLists
1094  {
1096  NoDisplayLists,
1097 
1100  GeometryDisplayLists,
1101 
1104  SegmentDisplayLists
1105  };
1106 
1115  enum class StaticModel
1116  {
1117 
1118  NoStaticModel,
1119  AttributeStaticModel,
1120  AttributeSpatialStaticModel
1121  };
1122 
1123 
1124 private:
1125  Performance() {}
1126 };
1127 
1128 
1129 class HPS_API AttributeLock
1130 {
1131 public:
1132 
1134  enum class Type : uint32_t
1135  {
1136  Everything = 0x01000000,
1137 
1138  Visibility = 0x02000000,
1139 
1140  VisibilityCuttingSections,
1141  VisibilityCutEdges,
1142  VisibilityCutFaces,
1143  VisibilityWindows,
1144  VisibilityText,
1145  VisibilityLines,
1146  VisibilityEdgeLights,
1147  VisibilityMarkerLights,
1148  VisibilityFaceLights,
1149  VisibilityGenericEdges,
1150  VisibilityHardEdges,
1151  VisibilityAdjacentEdges,
1152  VisibilityInteriorSilhouetteEdges,
1153  VisibilityShadowEmitting,
1154  VisibilityShadowReceiving,
1155  VisibilityShadowCasting,
1156  VisibilityMarkers,
1157  VisibilityVertices,
1158  VisibilityFaces,
1159  VisibilityPerimeterEdges,
1160  VisibilityNonCulledEdges,
1161  VisibilityMeshQuadEdges,
1162  VisibilityCutGeometry,
1163  VisibilityEdges,
1164  VisibilityGeometry,
1165  VisibilityLights,
1166  VisibilityShadows,
1167 
1168  Material = 0x03000000,
1169 
1170  MaterialGeometry,
1171  MaterialCutGeometry,
1172 
1173  MaterialAmbientLightUpColor,
1174  MaterialAmbientLightDownColor,
1175  MaterialAmbientLightColor,
1176 
1177  MaterialWindowColor,
1178  MaterialWindowContrastColor,
1179 
1180  MaterialLightColor,
1181  MaterialLineColor,
1182  MaterialMarkerColor,
1183  MaterialTextColor,
1184  MaterialCutEdgeColor,
1185 
1186  MaterialVertex,
1187  MaterialVertexDiffuse,
1188  MaterialVertexDiffuseColor,
1189  MaterialVertexDiffuseAlpha,
1190  MaterialVertexDiffuseTexture,
1191  MaterialVertexSpecular,
1192  MaterialVertexMirror,
1193  MaterialVertexTransmission,
1194  MaterialVertexEmission,
1195  MaterialVertexEnvironment,
1196  MaterialVertexBump,
1197  MaterialVertexGloss,
1198 
1199  MaterialEdge,
1200  MaterialEdgeDiffuse,
1201  MaterialEdgeDiffuseColor,
1202  MaterialEdgeDiffuseAlpha,
1203  MaterialEdgeDiffuseTexture,
1204  MaterialEdgeSpecular,
1205  MaterialEdgeMirror,
1206  MaterialEdgeTransmission,
1207  MaterialEdgeEmission,
1208  MaterialEdgeEnvironment,
1209  MaterialEdgeBump,
1210  MaterialEdgeGloss,
1211 
1212  MaterialFace,
1213  MaterialFaceDiffuse,
1214  MaterialFaceDiffuseColor,
1215  MaterialFaceDiffuseAlpha,
1216  MaterialFaceDiffuseTexture,
1217  MaterialFaceSpecular,
1218  MaterialFaceMirror,
1219  MaterialFaceTransmission,
1220  MaterialFaceEmission,
1221  MaterialFaceEnvironment,
1222  MaterialFaceBump,
1223  MaterialFaceGloss,
1224 
1225  MaterialBackFace,
1226  MaterialBackFaceDiffuse,
1227  MaterialBackFaceDiffuseColor,
1228  MaterialBackFaceDiffuseAlpha,
1229  MaterialBackFaceDiffuseTexture,
1230  MaterialBackFaceSpecular,
1231  MaterialBackFaceMirror,
1232  MaterialBackFaceTransmission,
1233  MaterialBackFaceEmission,
1234  MaterialBackFaceEnvironment,
1235  MaterialBackFaceBump,
1236  MaterialBackFaceGloss,
1237 
1238  MaterialFrontFace,
1239  MaterialFrontFaceDiffuse,
1240  MaterialFrontFaceDiffuseColor,
1241  MaterialFrontFaceDiffuseAlpha,
1242  MaterialFrontFaceDiffuseTexture,
1243  MaterialFrontFaceSpecular,
1244  MaterialFrontFaceMirror,
1245  MaterialFrontFaceTransmission,
1246  MaterialFrontFaceEmission,
1247  MaterialFrontFaceEnvironment,
1248  MaterialFrontFaceBump,
1249  MaterialFrontFaceGloss,
1250 
1251  MaterialCutFace,
1252  MaterialCutFaceDiffuse,
1253  MaterialCutFaceDiffuseColor,
1254  MaterialCutFaceDiffuseAlpha,
1255  MaterialCutFaceDiffuseTexture,
1256  MaterialCutFaceSpecular,
1257  MaterialCutFaceMirror,
1258  MaterialCutFaceTransmission,
1259  MaterialCutFaceEmission,
1260  MaterialCutFaceEnvironment,
1261  MaterialCutFaceBump,
1262  MaterialCutFaceGloss,
1263 
1264  Camera = 0x04000000,
1265  };
1266 
1267 private:
1268  AttributeLock() {}
1269 };
1270 
1271 class HPS_API Drawing
1272 {
1273 public:
1276  enum class Handedness
1277  {
1278  NoHandedness,
1279  Left,
1280  Right
1281  };
1282 
1285  enum class Overlay
1286  {
1288  NoOverlay,
1291  NormalOverlay,
1294  OverlayWithZValues,
1295 
1300  InPlace,
1301  };
1302 
1305  enum class ClipOperation
1306  {
1307  Keep,
1308  Remove,
1309  };
1310 
1313  enum class ClipSpace
1314  {
1315  Window,
1316  World,
1317  Object,
1318  };
1319 
1320 private:
1321  Drawing() {}
1322 };
1323 
1324 
1325 class HPS_API HiddenLine
1326 {
1327 public:
1331  enum class Algorithm
1332  {
1333  None,
1334  ZBuffer,
1335  ZSort,
1336  };
1337 
1338 private:
1339  HiddenLine() {}
1340 };
1341 
1342 
1344 class HPS_API Selection
1345 {
1346 public:
1349  enum class Level
1350  {
1351  Segment,
1352  Entity,
1353  Subentity,
1354  };
1355 
1358  enum class Algorithm
1359  {
1366  Visual,
1373  Analytic
1374  };
1375 
1378  enum class Granularity
1379  {
1380  General,
1381  Detailed
1382  };
1383 
1384 private:
1386  Selection();
1387 };
1388 
1389 
1393 
1394 //Begin Camera
1396 class HPS_API Camera
1397 {
1398 public:
1407  enum class Projection {
1408  Default=1,
1409  Perspective,
1410  Orthographic,
1411  Stretched,
1412  };
1415 private:
1416  Camera();
1417 };
1418 
1419 
1420 //Begin Selectability
1422 class HPS_API Selectability
1423 {
1424 public:
1428  enum class Value
1429  {
1430  Off=0,
1431  On,
1432  ForcedOn
1433  };
1434 
1435 private:
1436  Selectability();
1437 };
1438 
1439 // Begin Transparency
1441 class HPS_API Transparency
1442 {
1443 public:
1447  enum class Method
1448  {
1449  Off,
1450  Blended,
1451  ScreenDoor
1452  };
1453 
1457  enum class Algorithm
1458  {
1459  NoSorting,
1460  Painters,
1461  ZSortNicest,
1462  ZSortFastest,
1463  DepthPeeling
1464  };
1465 
1469  enum class AreaUnits
1470  {
1471  Percent,
1472  Pixels
1473  };
1474 
1475 private:
1476  Transparency() {}
1477 };
1478 
1479 
1480 
1481 //Begin Marker Attributes
1483 class HPS_API Marker
1484 {
1485 public:
1489  enum class SizeUnits
1490  {
1491  ScaleFactor,
1492  ObjectSpace,
1493  SubscreenRelative,
1494  WindowRelative,
1495  WorldSpace,
1496  Points,
1497  Pixels
1498 
1499  };
1500 private:
1501  Marker();
1502 };
1503 
1504 //Begin Sphere Attributes
1506 class HPS_API Sphere
1507 {
1508 public:
1509 
1510 private:
1511  Sphere();
1512 };
1513 
1514 
1515 //Begin Lighting Attributes
1517 class HPS_API Lighting
1518 {
1519 public:
1524  {
1525  Phong,
1526  Gouraud,
1527  Flat
1528  };
1529 
1530 private:
1531  Lighting();
1532 };
1533 
1535 class HPS_API Text
1536 {
1537 public:
1540  enum class Alignment
1541  {
1542  TopLeft,
1543  CenterLeft,
1544  BottomLeft,
1545  TopCenter,
1546  Center,
1547  BottomCenter,
1548  TopRight,
1549  CenterRight,
1550  BottomRight
1551  };
1552 
1555  enum class ReferenceFrame
1556  {
1557  WorldAligned,
1558  PathAligned
1559  };
1560 
1563  enum class Justification
1564  {
1565  LeftJustified,
1566  RightJustified,
1567  CenterJustified
1568  };
1569 
1572  enum class Transform
1573  {
1575  Transformable,
1578  NonTransformable,
1580  CharacterPositionOnly,
1583  CharacterPositionAdjusted
1584  };
1585 
1588  enum class Renderer
1589  {
1590  DefaultRenderer,
1591  DriverRenderer,
1592  TruetypeRenderer,
1593  };
1594 
1597  enum class Preference
1598  {
1599  Default,
1600  Vector,
1601  Raster,
1602  Exterior
1603  };
1604 
1607  enum class Rotation
1608  {
1609  NoRotation,
1610  Rotate,
1611  FollowPath
1612  };
1613 
1614 
1617  enum class SizeUnits
1618  {
1619  ObjectSpace,
1620  SubscreenRelative,
1621  WindowRelative,
1622  WorldSpace,
1623  Points,
1624  Pixels
1625  };
1626 
1630  {
1631  ObjectSpace,
1632  SubscreenRelative,
1633  WindowRelative,
1634  WorldSpace,
1635  Points,
1636  Pixels,
1637  Percent
1638  };
1639 
1642  enum class GreekingUnits
1643  {
1644  ObjectSpace,
1645  SubscreenRelative,
1646  WindowRelative,
1647  WorldSpace,
1648  Points,
1649  Pixels
1650  };
1651 
1654  enum class GreekingMode
1655  {
1656  Nothing,
1657  Lines,
1658  Box
1659  };
1660 
1663  enum class RegionAlignment
1664  {
1665  RegionTop,
1666  RegionCenter,
1667  RegionBottom
1668  };
1669 
1670 private:
1672  Text();
1673 };
1674 
1675 // Begin Line Attributes
1676 
1678 class HPS_API Line
1679 {
1680 public:
1684  enum class SizeUnits
1685  {
1686  ScaleFactor,
1687  ObjectSpace,
1688  SubscreenRelative,
1689  WindowRelative,
1690  WorldSpace,
1691  Points,
1692  Pixels
1693  };
1694 private:
1695  Line();
1696 };
1697 
1698 
1699 // Begin Edge Attributes
1700 
1702 class HPS_API Edge
1703 {
1704 public:
1708  enum class SizeUnits
1709  {
1710  ScaleFactor,
1711  ObjectSpace,
1712  SubscreenRelative,
1713  WindowRelative,
1714  WorldSpace,
1715  Points,
1716  Pixels
1717  };
1718 private:
1719  Edge();
1720 };
1721 
1722 
1724 class HPS_API CuttingSection
1725 {
1726 public:
1729  enum class Mode
1730  {
1731  None,
1732  Round,
1733  Square,
1734  Plane
1735  };
1736 
1739  enum class CappingLevel
1740  {
1741  Entity,
1742  Segment,
1743  SegmentTree
1744  };
1745 
1748  enum class CuttingLevel
1749  {
1750  Global,
1751  Local,
1752  };
1753 
1757  {
1758  Explicit,
1759  Implicit,
1760  };
1761 
1764  enum class GatheringLevel
1765  {
1766  Segment,
1767  SegmentTree
1768  };
1769 
1770 private:
1772  CuttingSection();
1773 };
1774 
1776 class HPS_API ContourLine
1777 {
1778 public:
1782  enum class Mode
1783  {
1784  Repeating,
1785  Explicit,
1786  };
1787 
1788 private:
1789  ContourLine();
1790 };
1791 
1794 enum class IOResult
1795 {
1796  Success,
1797  Failure,
1798  FileNotFound,
1799  UnableToOpenFile,
1800  InvalidOptions,
1801  InvalidSegment,
1802  InProgress,
1803  Canceled,
1804  UnableToLoadLibraries,
1805  VersionIncompatibility,
1806  InitializationFailed,
1807  UnsupportedFormat,
1808 };
1809 
1811 class HPS_API LinePattern
1812 {
1813 public:
1816  enum class SizeUnits
1817  {
1818  ObjectSpace,
1819  SubscreenRelative,
1820  WindowRelative,
1821  WorldSpace,
1822  Points,
1823  Pixels,
1824  ScaleFactor
1825  };
1826 
1829  enum class InsetBehavior
1830  {
1831  Overlap,
1832  Trim,
1833  Inline
1834  };
1835 
1839  enum class Join
1840  {
1841  MitreJoin,
1842  RoundJoin,
1843  BevelJoin
1844  };
1845 
1848  enum class Cap
1849  {
1852  ButtCap,
1855  SquareCap,
1858  RoundCap,
1860  MitreCap
1861  };
1862 
1865  enum class Justification
1866  {
1869  Center,
1871  Stretch
1872  };
1873 
1876  enum class Modifier
1877  {
1878  GlyphName,
1879  Enumerated
1880  };
1881 
1882 
1897  enum class Default
1898  {
1899  Solid,
1900  DashDot,
1901  Dashed,
1902  Dotted,
1903  Dash2Dot,
1904  Dash3Dot,
1905  LongDash,
1906  LongDashShortDash,
1907  LongDash2ShortDash,
1908  FineDot,
1909  };
1910 
1911 private:
1913  LinePattern();
1914 };
1915 
1916 
1917 //Begin Glyphs
1919 class HPS_API Glyph
1920 {
1921 public:
1924  enum class Fill
1925  {
1926  Unfilled,
1927  ContinuousFill,
1928  NewFill
1929  };
1930 
1933  enum class ColorSource
1934  {
1935  Normal,
1936  Explicit,
1937  Indexed
1938  };
1939 
1943  enum class Default
1944  {
1945  Circle,
1946  CircleWithDot,
1947  CircleWithPlus,
1948  CircleWithTimes,
1949  CircleWithCircle,
1950  SolidCircle,
1951  Dot,
1952  Plus,
1953  Times,
1954  Splat,
1955  Box,
1956  BoxWithDot,
1957  BoxWithTimes,
1958  SolidBox,
1959  Diamond,
1960  DiamondWithDot,
1961  DiamondWithPlus,
1962  SolidDiamond,
1963  TriangleUp,
1964  TriangleUpWithDot,
1965  SolidTriangleUp,
1966  TriangleDown,
1967  TriangleDownWithDot,
1968  SolidTriangleDown,
1969  TriangleRight,
1970  TriangleRightWithDot,
1971  SolidTriangleRight,
1972  TriangleLeft,
1973  TriangleLeftWithDot,
1974  SolidTriangleLeft,
1975  TriangleUpV,
1976  SolidTriangleUpV,
1977  TriangleDownV,
1978  SolidTriangleDownV,
1979  TriangleRightV,
1980  SolidTriangleRightV,
1981  TriangleLeftV,
1982  SolidTriangleLeftV,
1983  LetterY,
1984  LetterZ,
1985  CircleLetterY,
1986  CircleLetterZ,
1987  VerticalBar,
1988  HorizontalBar,
1989  SlantLeft,
1990  SlantRight,
1991  WidePlus,
1992  SolidWidePlus,
1993  WideTimes,
1994  SolidWideTimes,
1995  Pound,
1996  Sphere,
1997  };
1998 
1999 private:
2001  Glyph();
2002 };
2003 
2004 
2006 class HPS_API Bounding
2007 {
2008 public:
2012  enum class Type
2013  {
2014  None,
2015  Sphere,
2016  Cuboid
2017  };
2018 
2019 private:
2020  Bounding() {}
2021 };
2022 
2024 class HPS_API Grid
2025 {
2026 public:
2029  enum class Type
2030  {
2031  Quadrilateral,
2032  Radial
2033  };
2034 
2035 private:
2036  Grid();
2037 };
2038 
2039 
2041 {
2042 public:
2043  enum class UserData
2044  {
2045  Nothing,
2046  Discard,
2047  Preserve,
2048  Merge,
2049  Localize,
2050  };
2051 
2052  enum class Scope
2053  {
2054  SubSegments,
2055  SubsegmentsAndIncludes,
2056  };
2057 
2058  enum class Expansion
2059  {
2060  None,
2061  Includes,
2062  References,
2063  IncludesAndReferences,
2064  };
2065 
2066  enum class Matrix
2067  {
2068  Nothing,
2069  Localize,
2070  Collapse,
2071  };
2072 
2073  enum class Reorganization
2074  {
2075  None,
2076  Attribute,
2077  Spatial,
2078  AttributeSpatial,
2079  };
2080 };
2081 
2082  typedef double Time;
2083 
2084 #ifdef _MSC_VER
2085 # ifndef HPS_INLINE
2086 # define HPS_INLINE __forceinline
2087 # endif
2088 #else
2089 # define HPS_INLINE inline
2090 #endif
2091 
2092 #ifndef HPS_UNREFERENCED
2093 #define HPS_UNREFERENCED(param) ((void)(param))
2094 #endif
2095 
2096 
2097 const double PI = 3.141592653589793238462643383279502884197169399375105820974944592308;
2098 
2099 template<typename T>
2100 HPS_INLINE T Degrees_To_Radians(T const & degrees)
2101 {
2102  return degrees * (T)(PI / 180.0);
2103 }
2104 
2105 template<typename T>
2106 HPS_INLINE T Radians_To_Degrees(T const & radians)
2107 {
2108  return radians * (T)(180.0 / PI);
2109 }
2110 
2111 template<typename T>
2112 HPS_INLINE void SinCos(T const & angle, T & sine, T & cosine) {
2113  T a = Degrees_To_Radians(angle);
2114  cosine = cos(a);
2115  sine = sin(a);
2116 }
2117 
2118 template<typename T>
2119 HPS_INLINE T Cos(T const & angle) {
2120  return cos (Degrees_To_Radians(angle));
2121 }
2122 
2123 template<typename T>
2124 HPS_INLINE T Sin(T const & angle) {
2125  return sin (Degrees_To_Radians(angle));
2126 }
2127 
2128 template<typename T>
2129 HPS_INLINE T ACos(T const & x) {
2130  if (x > 1)
2131  return 0;
2132  if (x < -1)
2133  return 180;
2134  return Radians_To_Degrees(acos(x));
2135 }
2136 
2137 template<typename T>
2138 HPS_INLINE T ATan2(T const & y, T const & x) {
2139  if (x == 0 && y == 0)
2140  return 0;
2141  return Radians_To_Degrees(atan2(y, x));
2142 }
2143 
2144 
2145 template <typename F> struct Float_Traits {};
2146 template <> struct Float_Traits<float> {
2147  typedef double Alternative;
2148  static const int Type = 1;
2149  static float Epsilon () { return 1.0e-30f; }
2150 };
2151 template <> struct Float_Traits<double> {
2152  typedef float Alternative;
2153  static const int Type = 2;
2154  static double Epsilon () { return 1.0e-300; }
2155 };
2156 
2157 
2158 
2160 class HPS_API Float {
2161 private:
2162  enum Parts {
2163 # if HOOPS_BIGENDIAN
2164  High, Low
2165 # else
2166  Low, High
2167 # endif
2168  };
2169 
2170  // & functions for a float represented in an int, * version for a double in an array of 2 ints
2171  static HPS_INLINE bool is_infinite(int32_t const & v) { return (v & 0x7FFFFFFF) == 0x7F800000; }
2172  static HPS_INLINE bool is_infinite(uint32_t const & v) { return (v & 0x7FFFFFFF) == 0x7F800000; }
2173  static HPS_INLINE bool is_infinite(int32_t const * v) { return (v[High] & 0x7FFFFFFF) == 0x7FF00000 && v[Low] == 0; }
2174  static HPS_INLINE bool is_infinite(uint32_t const * v) { return (v[High] & 0x7FFFFFFF) == 0x7FF00000 && v[Low] == 0; }
2175 
2176  static HPS_INLINE bool is_nan(int32_t const & v) {
2177  uint32_t exp = v & 0x7F800000, mantissa = v & 0x007FFFFF;
2178  return exp == 0x7F800000 && mantissa != 0;
2179  }
2180  static HPS_INLINE bool is_nan(uint32_t const & v) {
2181  uint32_t exp = v & 0x7F800000, mantissa = v & 0x007FFFFF;
2182  return exp == 0x7F800000 && mantissa != 0;
2183  }
2184  static HPS_INLINE bool is_nan(int32_t const * v) {
2185  uint32_t exp = v[High] & 0x7FF00000, mantissa_high = v[High] & 0x000FFFFF;
2186  return exp == 0x7FF00000 && (mantissa_high | v[Low]) != 0;
2187  }
2188  static HPS_INLINE bool is_nan(uint32_t const * v) {
2189  uint32_t exp = v[High] & 0x7FF00000, mantissa_high = v[High] & 0x000FFFFF;
2190  return exp == 0x7FF00000 && (mantissa_high | v[Low]) != 0;
2191  }
2192 
2193  static HPS_INLINE bool is_special(int32_t const & v) { return (v & 0x7F800000) == 0x7F800000; }
2194  static HPS_INLINE bool is_special(uint32_t const & v) { return (v & 0x7F800000) == 0x7F800000; }
2195  static HPS_INLINE bool is_special(int32_t const * v) { return (v[High] & 0x7FFFFFFF) == 0x7FF00000; }
2196  static HPS_INLINE bool is_special(uint32_t const * v) { return (v[High] & 0x7FFFFFFF) == 0x7FF00000; }
2197 public:
2198 
2200  static const float Infinity;
2202  static const float NegativeInfinity;
2203 
2205  static HPS_INLINE bool IsInfinite(float const & a) { return is_infinite (extract_uint32_t(a)); }
2206  static HPS_INLINE bool IsInfinite(double const & a) {
2207  uint32_t v[2];
2208  memcpy (v, &a, sizeof(double));
2209  return is_infinite (v);
2210  }
2211 
2213  static HPS_INLINE bool IsNAN(float const & a) { return is_nan (extract_uint32_t(a)); }
2214  static HPS_INLINE bool IsNAN(double const & a) {
2215  uint32_t v[2];
2216  memcpy (v, &a, sizeof(double));
2217  return is_nan (v);
2218  }
2219 
2221  static HPS_INLINE bool IsAbnormal(float const & a) { return is_special (extract_uint32_t(a)); }
2222  static HPS_INLINE bool IsAbnormal(double const & a) {
2223  uint32_t v[2];
2224  memcpy (v, &a, sizeof(double));
2225  return is_special (v);
2226  }
2227 
2230  static HPS_INLINE bool Equals(float const & a, float const & b, int tolerance = 32);
2231  static HPS_INLINE bool Equals(double const & a, double const & b, int tolerance = 32);
2232 
2233 #ifndef HOOPS_DEFINED
2234  template <typename Alloc>
2235  static HPS_INLINE bool Equals(std::vector<float, Alloc> const & a, std::vector<float, Alloc> const & b, int tolerance = 32)
2236  {
2237  if (a.size() != b.size())
2238  return false;
2239 
2240  auto it1 = a.begin();
2241  auto it2 = b.begin();
2242  auto const end = a.end();
2243  for ( ; it1 != end; ++it1, ++it2)
2244  {
2245  if (!Equals(*it1, *it2, tolerance))
2246  return false;
2247  }
2248  return true;
2249  }
2250 #endif
2251 
2252  static HPS_INLINE uint32_t extract_sign_bit(float const & a) {
2253  return extract_uint32_t(a) & 0x80000000;
2254  }
2255  static HPS_INLINE uint32_t extract_sign_bit(double const & a) {
2256  uint32_t v[2];
2257  memcpy (v, &a, sizeof(double));
2258  return v[High] & 0x80000000;
2259  }
2260 
2261  static HPS_INLINE void apply_sign_bit(float & a, uint32_t const & sign_bit) {
2262  uint32_t v = extract_uint32_t(a);
2263  v &= 0x7FFFFFFF;
2264  v |= sign_bit;
2265  inject_uint32_t(a, v);
2266  }
2267  static HPS_INLINE void apply_sign_bit(double & a, uint32_t const & sign_bit) {
2268  uint32_t v[2];
2269  memcpy (v, &a, sizeof(double));
2270  v[High] &= 0x7FFFFFFF;
2271  v[High] |= sign_bit;
2272  memcpy (&a, v, sizeof(double));
2273  }
2274 
2275 
2276  static HPS_INLINE unsigned char unit_to_byte(float const & a) {
2277  uint32_t v = extract_uint32_t(a);
2278 
2279  v &= 0x7FFFFFFF;
2280  if (v < 0x3B800000)
2281  return 0;
2282 
2283  v--;
2284 
2285  uint32_t exp = v >> 23;
2286  uint32_t man = (v & 0x007FFFFF) | 0x00800000;
2287 
2288  return (unsigned char) (man >> (16 + 126 - exp));
2289  }
2290 
2291  static HPS_INLINE unsigned char unit_to_byte_scaled(float const & a, unsigned char mix) {
2292  uint32_t v = extract_uint32_t(a);
2293 
2294  v &= 0x7FFFFFFF;
2295  if (v < 0x3B800000)
2296  return 0;
2297 
2298  v--;
2299 
2300  uint32_t exp = v >> 23;
2301  uint32_t man = (v & 0x007FFFFF) | 0x00800000;
2302 
2303  uint32_t x = (man >> (16 + 126 - exp));
2304 
2305  return (unsigned char) ((x * (mix+1)) >> 8);
2306  }
2307 
2308 
2309  static HPS_INLINE bool match(float const & a, float const & b) {
2310  uint32_t va = extract_uint32_t(a);
2311  uint32_t vb = extract_uint32_t(b);
2312 
2313  if (((va | vb) & 0x7FFFFFFF) == 0)
2314  return true;
2315 
2316  return va == vb;
2317  }
2318  static HPS_INLINE bool match(double const & a, double const & b) {
2319  return a == b;
2320  }
2321 
2322 
2323  static HPS_INLINE void replace_if_smaller(float & a, float const & b) {
2324  uint32_t va = extract_uint32_t(a);
2325  uint32_t vb = extract_uint32_t(b);
2326 
2327  uint32_t a_sign = va & 0x80000000;
2328  uint32_t b_sign = vb & 0x80000000;
2329 
2330  (int32_t&)a_sign >>= 31;
2331  (int32_t&)b_sign >>= 31;
2332 
2333  uint32_t mash = (a_sign&b_sign);
2334 
2335  va ^= mash;
2336  vb ^= mash;
2337 
2338  if ((int32_t&)vb < (int32_t&)va)
2339  memcpy(&a, &b, sizeof(float));
2340  }
2341  static HPS_INLINE void replace_if_smaller(double & a, double const & b) {
2342  if (b < a)
2343  a = b;
2344  }
2345 
2346  static HPS_INLINE void replace_if_larger(float & a, float const & b) {
2347  uint32_t va = extract_uint32_t(a);
2348  uint32_t vb = extract_uint32_t(b);
2349 
2350  uint32_t a_sign = va & 0x80000000;
2351  uint32_t b_sign = vb & 0x80000000;
2352 
2353  (int32_t&)a_sign >>= 31;
2354  (int32_t&)b_sign >>= 31;
2355 
2356  uint32_t mash = (a_sign&b_sign);
2357 
2358  va ^= mash;
2359  vb ^= mash;
2360 
2361  if ((int32_t&)vb > (int32_t&)va)
2362  memcpy(&a, &b, sizeof(float));
2363  }
2364  static HPS_INLINE void replace_if_larger(double & a, double const & b) {
2365  if (b > a)
2366  a = b;
2367  }
2368 
2369 
2370  static HPS_INLINE uint32_t extract_uint32_t(float const & a) {
2371  uint32_t i;
2372  memcpy(&i, &a, sizeof(float));
2373  return i;
2374  }
2375 
2376  static HPS_INLINE void inject_uint32_t(float & a, uint32_t const & i) {
2377  memcpy(&a, &i, sizeof(float));
2378  }
2379 
2380  static HPS_INLINE float C2F(unsigned char x) {
2381  //return (float)x * (1.0f/255.0f);
2382  return char_to_float[x];
2383  }
2384 
2385 
2386  // SSE convenience functions
2387  static HPS_INLINE void pack_4(float const & f, float * m) {
2388  memcpy(&m[0], &f, sizeof(float));
2389  memcpy(&m[1], &f, sizeof(float));
2390  memcpy(&m[2], &f, sizeof(float));
2391  memcpy(&m[3], &f, sizeof(float));
2392  }
2393 
2394  static HPS_INLINE void pack_4(float const & f0, float const & f1, float const & f2, float const & f3, float * m) {
2395  memcpy(&m[0], &f0, sizeof(float));
2396  memcpy(&m[1], &f1, sizeof(float));
2397  memcpy(&m[2], &f2, sizeof(float));
2398  memcpy(&m[3], &f3, sizeof(float));
2399  }
2400 
2401  static HPS_INLINE void unpack_4(float * f0, float const * const m) {
2402  memcpy(f0, m, sizeof(float)*4);
2403  }
2404 
2405  static HPS_INLINE void unpack_4(float & f0, float & f1, float & f2, float & f3, float const * const m) {
2406  memcpy(&f0, &m[0], sizeof(float));
2407  memcpy(&f1, &m[1], sizeof(float));
2408  memcpy(&f2, &m[2], sizeof(float));
2409  memcpy(&f3, &m[3], sizeof(float));
2410  }
2411 
2412 private:
2413  static const float char_to_float[256];
2414 
2415  Float();
2416 };
2417 
2418 
2420 
2421 
2422 template <typename T> HPS_INLINE T * Alter (T const * a) { return const_cast<T *>(a); }
2423 template <typename T> HPS_INLINE T & Alter (T const & a) { return const_cast<T &>(a); }
2424 
2425 template <typename T> HPS_INLINE T Abs (T const & a) { return a < 0 ? -a : a; }
2426 template <typename T> HPS_INLINE int Compare (T const & a, T const & b) { return a == b ? 0 : a < b ? -1 : 1; }
2427 template <typename T> HPS_INLINE int Sign (T const & a) { return Compare(a,(T)0); }
2428 template <typename T> HPS_INLINE void Swap (T & a, T & b) { T temp = a; a = b; b = temp; }
2429 template <typename T> HPS_INLINE int Floor(T const & a) { return ((a > 0 || (T)(int)a == a) ? (int)a : ((int)a - 1)); }
2430 template <typename T> HPS_INLINE int Ceiling(T const & a) { return ((a < 0 || (T)(int)a == a) ? (int)a : ((int)a + 1)); }
2431 
2432 template <typename T> HPS_INLINE T const & Min (T const & a, T const & b) { return a < b ? a : b; }
2433 template <typename T> HPS_INLINE T const & Min (T const & a, T const & b, T const & c) { return Min(Min(a,b),c); }
2434 template <typename T> HPS_INLINE T const & Min (T const & a, T const & b, T const & c, T const & d) { return Min(Min(a, b, c),d); }
2435 template <typename T> HPS_INLINE T const & Min (T const & a, T const & b, T const & c, T const & d, T const & e) { return Min(Min(a,b,c,d),e); }
2436 template <typename T> HPS_INLINE T const & Min (T const & a, T const & b, T const & c, T const & d, T const & e, T const & f) { return Min(Min(a,b,c,d,e),f); }
2437 
2438 template <typename T> HPS_INLINE T const & Max (T const & a, T const & b) { return a > b ? a : b; }
2439 template <typename T> HPS_INLINE T const & Max (T const & a, T const & b, T const & c) { return Max(Max(a,b),c); }
2440 template <typename T> HPS_INLINE T const & Max (T const & a, T const & b, T const & c, T const & d) { return Max(Max(a, b, c),d); }
2441 template <typename T> HPS_INLINE T const & Max (T const & a, T const & b, T const & c, T const & d, T const & e) { return Max(Max(a,b,c,d),e); }
2442 template <typename T> HPS_INLINE T const & Max (T const & a, T const & b, T const & c, T const & d, T const & e, T const & f) { return Max(Max(a,b,c,d,e),f); }
2443 
2444 template <typename T> HPS_INLINE T const & Clamp(T const & x, T const & min, T const & max) { return x < min ? min : x > max ? max : x; }
2445 
2446 
2447 template <> HPS_INLINE float Abs<float> (float const & a) {
2448  uint32_t v = Float::extract_uint32_t(a);
2449  v &= 0x7FFFFFFF;
2450  float f;
2451  Float::inject_uint32_t(f,v);
2452  return f;
2453 }
2454 
2455 template <> HPS_INLINE int Sign<float> (float const & a) {
2456  uint32_t v = Float::extract_uint32_t(a);
2457 
2458  if ((v & 0x7FFFFFFF) == 0)
2459  return 0;
2460 
2461  return ((int32_t)(v & 0x80000000)>>31) | 0x01;
2462 }
2463 
2464 template <> HPS_INLINE int Compare<float> (float const & a, float const & b) {
2465  int a_sign = Sign(a);
2466  int b_sign = Sign(b);
2467 
2468  if (a_sign != b_sign)
2469  return Compare(a_sign, b_sign);
2470 
2471  uint32_t v = Float::extract_uint32_t(a);
2472  uint32_t u = Float::extract_uint32_t(b);
2473 
2474  return Compare((v & 0x7FFFFFFF), (u & 0x7FFFFFFF)) * a_sign;
2475 }
2476 
2477 template <> HPS_INLINE float const & Min<float> (float const & a, float const & b) {
2478  if (Compare(a,b)>0)
2479  return b;
2480  return a;
2481 }
2482 
2483 template <> HPS_INLINE float const & Max<float> (float const & a, float const & b) {
2484  if (Compare(a,b)>0)
2485  return a;
2486  return b;
2487 }
2488 
2489 
2491 
2492 HPS_INLINE bool Float::Equals(float const & a, float const & b, int tolerance) {
2493  int32_t va = Float::extract_uint32_t(a);
2494  int32_t vb = Float::extract_uint32_t(b);
2495 
2496  if (is_special(va) || is_special(vb)) {
2497  if (is_infinite(va) || is_infinite(vb))
2498  return va == vb; // final check is for sign bits same
2499  if (is_nan(va) || is_nan(vb))
2500  return false;
2501  }
2502 
2503  int const close_to_zero = 0x36A00000; // (approx) 5.0e-6f;
2504  if ((va & 0x7FFFFFFF) == 0)
2505  return (vb & 0x7FFFFFFF) < close_to_zero;
2506  else if ((vb & 0x7FFFFFFF) == 0)
2507  return (va & 0x7FFFFFFF) < close_to_zero;
2508 
2509  uint32_t sign_mask = va ^ vb;
2510  (int32_t &)sign_mask >>= 31;
2511 
2512  int32_t diff = ((va + sign_mask) ^ (sign_mask & 0x7FFFFFFF)) -vb;
2513  int32_t v1 = tolerance + diff;
2514  int32_t v2 = tolerance - diff;
2515  return (v1|v2) >= 0;
2516 }
2517 
2518 HPS_INLINE bool Float::Equals(double const & a, double const & b, int tolerance) {
2519  int32_t va[2], vb[2];
2520  memcpy (va, &a, sizeof(double));
2521  memcpy (vb, &b, sizeof(double));
2522 
2523  if (is_special(va) || is_special(vb)) {
2524  if (is_infinite(va) || is_infinite(vb))
2525  return va[High] == vb[High] && va[Low] == vb[Low]; // final check is for sign bits same
2526  if (is_nan(va) || is_nan(vb))
2527  return false;
2528  }
2529 
2530  if ((va[High] == 0 && va[Low] == 0) || (vb[High] == 0 && vb[Low] == 0))
2531  return Abs(a - b) < 0.000000000000005;
2532 
2533  if (extract_sign_bit(a) != extract_sign_bit(b))
2534  return a == b; //-V550
2535 
2536  if (va[High] != vb[High])
2537  return false;
2538 
2539  return Abs(va[Low] - vb[Low]) <= tolerance;
2540 }
2541 
2543 
2544 
2545 HPS_INLINE bool Is_Abnormal (float const & f) { return Float::IsAbnormal (f); }
2546 HPS_INLINE bool Is_Abnormal (double const & d) { return Float::IsAbnormal (d); }
2547 
2548 template <typename T>
2549 HPS_INLINE bool Is_Abnormal (size_t count, T const * t) {
2550  while (count-- > 0)
2551  if (Is_Abnormal (*t++))
2552  return true;
2553  return false;
2554 }
2555 
2556 template <typename T>
2557 HPS_INLINE bool Is_Abnormal (int count, T const * t) {
2558  return count >= 0 && Is_Abnormal((size_t)count, t);
2559 }
2560 
2561 
2563 
2564 
2565 template <typename F> class HPS_TEMPLATE_API Vector_3D;
2566 template <typename F> class HPS_TEMPLATE_API Plane_3D;
2567 template <typename F> class HPS_TEMPLATE_API Vector_2D;
2568 template <typename F> class HPS_TEMPLATE_API Point_2D;
2569 
2570 
2571 template <typename F>
2572 class HPS_TEMPLATE_API Point_3D {
2573  public:
2574  F x;
2575  F y;
2576  F z;
2577 
2578  Point_3D () {}
2579  Point_3D (F v1, F v2, F v3) : x (v1), y (v2), z (v3) {}
2580 
2581  template <typename D>
2582  explicit Point_3D (Point_3D<D> const & that) : x ((F)that.x), y ((F)that.y), z ((F)that.z) {}
2583 
2584  explicit Point_3D (Vector_3D<F> const & v);
2585  explicit Point_3D (Vector_2D<F> const & v);
2586  explicit Point_3D (Point_2D<F> const & that);
2587 
2588  Point_3D const operator- () const { return Point_3D (-x, -y, -z); }
2589 
2590  bool operator== (Point_3D const & p) const { return x == p.x && y == p.y && z == p.z; }
2591  bool operator!= (Point_3D const & p) const { return !(*this == p); }
2592 
2593  bool Equals(Point_3D const & p, int in_tolerance = 32) const {
2594  return Float::Equals(x, p.x, in_tolerance) &&
2595  Float::Equals(y, p.y, in_tolerance) &&
2596  Float::Equals(z, p.z, in_tolerance);
2597  }
2598 
2599 
2600  Point_3D & operator*= (F s) { x *= s; y *= s; z *= s; return *this; }
2601  Point_3D & operator/= (F s) { return operator*= ((F)1 / s); }
2602  Point_3D const operator* (F s) const { return Point_3D (x * s, y * s, z * s); }
2603  Point_3D const operator/ (F s) const { return operator* ((F)1 / s); }
2604 
2605  F & operator[] (size_t i) { return (&x)[i]; }
2606  F const & operator[] (size_t i) const { return (&x)[i]; }
2607 
2608  Point_3D & operator+= (Vector_3D<F> const & v);
2609  Point_3D & operator-= (Vector_3D<F> const & v);
2610  Point_3D & operator*= (Vector_3D<F> const & v);
2611  Point_3D & operator/= (Vector_3D<F> const & v);
2612  Point_3D const operator* (Vector_3D<F> const & v) const;
2613  Point_3D const operator/ (Vector_3D<F> const & v) const;
2614 
2615  Point_3D & operator+= (Vector_2D<F> const & v);
2616  Point_3D & operator-= (Vector_2D<F> const & v);
2617  Point_3D & operator*= (Vector_2D<F> const & v);
2618  Point_3D & operator/= (Vector_2D<F> const & v);
2619  Point_3D const operator* (Vector_2D<F> const & v) const;
2620  Point_3D const operator/ (Vector_2D<F> const & v) const;
2621 
2622  Vector_3D<F> const operator- (Point_3D const & p) const;
2623 
2624  Point_3D const operator+ (Vector_3D<F> const & v) const;
2625  Point_3D const operator- (Vector_3D<F> const & v) const;
2626 
2627  Point_3D const operator+ (Vector_2D<F> const & v) const;
2628  Point_3D const operator- (Vector_2D<F> const & v) const;
2629 
2630  static HPS_INLINE Point_3D Origin() {return Point_3D (0, 0, 0);};
2631  static HPS_INLINE Point_3D Zero() {return Point_3D (0, 0, 0);}; //-V524
2632 };
2633 
2634 typedef Point_3D<float> Point;
2635 typedef Point_3D<double> DPoint;
2636 
2637 
2638 
2639 template <typename F, typename S>
2640 HPS_INLINE Point_3D<F> operator* (S s, Point_3D<F> const & a) { return Point_3D<F> (F(s * a.x), F(s * a.y), F(s * a.z)); }
2641 
2642 template <typename F>
2643 HPS_INLINE Point_3D<F> Midpoint (Point_3D<F> const & a, Point_3D<F> const & b) {
2644  return Point_3D<F> (a.x + b.x, a.y + b.y, a.z + b.z) * 0.5f;
2645 }
2646 
2647 template <typename F>
2648 HPS_INLINE Point_3D<F> Midpoint (Point_3D<F> const & a, Point_3D<F> const & b, Point_3D<F> const & c) {
2649  return Point_3D<F> (a.x + b.x + c.x, a.y + b.y + c.y, a.z + b.z + c.z) * (F)(1.0/3.0);
2650 }
2651 
2652 template <typename F>
2653 HPS_INLINE bool Is_Abnormal (Point_3D<F> const & p) {
2654  return Is_Abnormal (p.x) || Is_Abnormal (p.y) || Is_Abnormal (p.z);
2655 }
2656 
2657 
2658 template <typename F>
2659 class HPS_TEMPLATE_API Point_2D {
2660 public:
2661  F x;
2662  F y;
2663 
2664  Point_2D () {}
2665  Point_2D (F v1, F v2) : x (v1), y (v2) {}
2666 
2667  template <typename D>
2668  explicit Point_2D (Point_2D<D> const & that) : x ((F)that.x), y ((F)that.y) {}
2669 
2670  explicit Point_2D (Point_3D<F> const & that) : x ((F)that.x), y ((F)that.y) {}
2671  explicit Point_2D (Vector_2D<F> const & v);
2672 
2673  Point_2D const operator- () const { return Point_2D (-x, -y); }
2674 
2675  bool operator== (Point_2D const & p) const { return x == p.x && y == p.y; }
2676  bool operator!= (Point_2D const & p) const { return !(*this == p); }
2677 
2678  bool Equals(Point_2D const & p, int in_tolerance = 32) const {
2679  return Float::Equals(x, p.x, in_tolerance) && Float::Equals(y, p.y, in_tolerance);
2680  }
2681 
2682 
2683  Point_2D & operator*= (F s) { x *= s; y *= s; return *this; }
2684  Point_2D & operator/= (F s) { return operator*= ((F)1 / s); }
2685  Point_2D const operator* (F s) const { return Point_2D (x * s, y * s); }
2686  Point_2D const operator/ (F s) const { return operator* ((F)1 / s); }
2687 
2688  F & operator[] (size_t i) { return (&x)[i]; }
2689  F const & operator[] (size_t i) const { return (&x)[i]; }
2690 
2691  Point_2D & operator+= (Vector_2D<F> const & v);
2692  Point_2D & operator-= (Vector_2D<F> const & v);
2693  Point_2D & operator*= (Vector_2D<F> const & v);
2694  Point_2D & operator/= (Vector_2D<F> const & v);
2695  Point_2D const operator* (Vector_2D<F> const & v) const;
2696  Point_2D const operator/ (Vector_2D<F> const & v) const;
2697 
2698  Vector_2D<F> const operator- (Point_2D const & p) const;
2699 
2700  Point_2D const operator+ (Vector_2D<F> const & v) const;
2701  Point_2D const operator- (Vector_2D<F> const & v) const;
2702 
2703  static HPS_INLINE Point_2D Origin() {return Point_2D (0, 0);};
2704  static HPS_INLINE Point_2D Zero() {return Point_2D (0, 0);}; //-V524
2705 };
2706 
2707 typedef Point_2D<float> Point2D;
2708 typedef Point_2D<double> DPoint2D;
2709 
2710 template <typename F>
2711 HPS_INLINE Point_3D<F>::Point_3D (Point_2D<F> const & that) : x (that.x), y (that.y), z (0) {}
2712 
2713 template <typename F, typename S>
2714 HPS_INLINE Point_2D<F> operator* (S s, Point_2D<F> const & a) { return Point_2D<F> (F(s * a.x), F(s * a.y)); }
2715 
2716 template <typename F>
2717 HPS_INLINE Point_2D<F> Midpoint (Point_2D<F> const & a, Point_2D<F> const & b) {
2718  return Point_2D<F> (a.x + b.x, a.y + b.y) * 0.5f;
2719 }
2720 
2721 template <typename F>
2722 HPS_INLINE Point_2D<F> Midpoint (Point_2D<F> const & a, Point_2D<F> const & b, Point_2D<F> const & c) {
2723  return Point_2D<F> (a.x + b.x + c.x, a.y + b.y + c.y, a.z + b.z + c.z) * (F)(1.0/3.0);
2724 }
2725 
2726 template <typename F>
2727 HPS_INLINE bool Is_Abnormal (Point_2D<F> const & p) {
2728  return Is_Abnormal (p.x) || Is_Abnormal (p.y);
2729 }
2730 
2731 
2732 template <typename F>
2733 class HPS_TEMPLATE_API Vector_3D {
2734  public:
2735  F x;
2736  F y;
2737  F z;
2738 
2739  Vector_3D () {}
2740  Vector_3D (F v1, F v2, F v3) : x (v1), y (v2), z (v3) {}
2741  template <typename D>
2742  explicit Vector_3D (Vector_3D<D> const & that) : x ((F)that.x), y ((F)that.y), z ((F)that.z) {}
2743  explicit Vector_3D(Point_3D<F> const & p) : x(p.x), y(p.y), z(p.z) {}
2744  explicit Vector_3D(Plane_3D<F> const & p);
2745 
2746  explicit Vector_3D (Vector_2D<F> const & that);
2747 
2748  Vector_3D const operator- () const { return Vector_3D (-x, -y, -z); }
2749 
2750  bool operator== (Vector_3D const & v) const {
2751  return Float::match(x, v.x) && Float::match(y, v.y) && Float::match(z, v.z);
2752  }
2753  bool operator!= (Vector_3D const & v) const { return !(*this == v); }
2754 
2755  bool Equals(Vector_3D const & v, int in_tolerance = 32) const {
2756  return Float::Equals(x, v.x, in_tolerance) &&
2757  Float::Equals(y, v.y, in_tolerance) &&
2758  Float::Equals(z, v.z, in_tolerance);
2759  }
2760 
2761  Vector_3D & operator+= (Vector_3D const & v) { x += v.x; y += v.y; z += v.z; return *this; }
2762  Vector_3D & operator-= (Vector_3D const & v) { x -= v.x; y -= v.y; z -= v.z; return *this; }
2763  Vector_3D const operator+ (Vector_3D const & v) const { return Vector_3D (x + v.x, y + v.y, z + v.z); }
2764  Vector_3D const operator- (Vector_3D const & v) const { return Vector_3D (x - v.x, y - v.y, z - v.z); }
2765 
2766  Vector_3D & operator*= (F s) { x *= s; y *= s; z *= s; return *this; }
2767  Vector_3D & operator/= (F s) { return operator*= (1.0f / s); }
2768  Vector_3D const operator* (F s) const { return Vector_3D (x * s, y * s, z * s); }
2769  Vector_3D const operator/ (F s) const { return operator* (1.0f / s); }
2770 
2771  F & operator[] (size_t i) { return (&x)[i]; }
2772  F const & operator[] (size_t i) const { return (&x)[i]; }
2773 
2774  HPS_INLINE double Length () const { return sqrt (LengthSquared()); }
2775 
2776  HPS_INLINE double LengthSquared () const { return (double)x*(double)x + (double)y*(double)y + (double)z*(double)z; }
2777 
2778  HPS_INLINE double Length2D () const { return sqrt (LengthSquared2D()); }
2779 
2780  HPS_INLINE double LengthSquared2D () const { return (double)x*(double)x + (double)y*(double)y;}
2781 
2782  HPS_INLINE Vector_3D & Normalize (bool check_range = false, F epsilon = Float_Traits<F>::Epsilon()) {// not const &; allow V.normalize() *= S;
2783  if (check_range) {
2784  F range = Max (Abs (x), Abs (y), Abs (z));
2785  if (range > F(1.0e10))
2786  operator/= (range);
2787  }
2788 
2789  F len = (F)Length();
2790  if (len > epsilon)
2791  operator/= (len);
2792  else
2793  *this = Zero();
2794  return *this;
2795  }
2796  HPS_INLINE Vector_3D & Normalize (F epsilon) { return Normalize (false, epsilon); }
2797 
2798  HPS_INLINE F Magnitude () const { return Max (Abs(x), Abs(y), Abs(z)); }
2799  HPS_INLINE F Manhattan () const { return Abs(x)+Abs(y)+Abs(z); }
2800 
2801  HPS_INLINE F Dot (Vector_3D const & v) const { return x * v.x + y * v.y + z * v.z; }
2802 
2803  HPS_INLINE Vector_3D Cross (Vector_3D const & v) const {
2804  return Vector_3D (y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x);
2805  }
2806 
2807 
2808  HPS_INLINE Vector_3D Scale (Vector_3D const & v) const {
2809  return Vector_3D (x * v.x, y * v.y, z * v.z);
2810  }
2811 
2812  static HPS_INLINE Vector_3D XAxis() {return Vector_3D (1, 0, 0);};
2813  static HPS_INLINE Vector_3D YAxis() {return Vector_3D (0, 1, 0);};
2814  static HPS_INLINE Vector_3D ZAxis() {return Vector_3D (0, 0, 1);};
2815  static HPS_INLINE Vector_3D Zero() {return Vector_3D (0, 0, 0);};
2816  static HPS_INLINE Vector_3D Unit() {return Vector_3D (1, 1, 1);};
2817 };
2818 
2819 typedef Vector_3D<float> Vector;
2820 typedef Vector_3D<double> DVector;
2821 
2822 
2823 template <typename F, typename S>
2824 HPS_INLINE Vector_3D<F> operator* (S s, Vector_3D<F> const & v) {return Vector_3D<F> (F(s * v.x), F(s * v.y), F(s * v.z)); }
2825 
2826 template <typename F>
2827 HPS_INLINE bool Is_Abnormal (Vector_3D<F> const & v) {
2828  return Is_Abnormal (v.x) || Is_Abnormal (v.y) || Is_Abnormal (v.z);
2829 }
2830 
2831 
2832 template <typename F>
2833 HPS_INLINE Point_3D<F>::Point_3D(Vector_3D<F> const & v) : x(v.x), y(v.y), z(v.z) {}
2834 
2835 template <typename F>
2836 HPS_INLINE Point_3D<F> & Point_3D<F>::operator+= (Vector_3D<F> const & v) { x += v.x; y += v.y; z += v.z; return *this; }
2837 template <typename F>
2838 HPS_INLINE Point_3D<F> & Point_3D<F>::operator-= (Vector_3D<F> const & v) { x -= v.x; y -= v.y; z -= v.z; return *this; }
2839 
2840 template <typename F>
2841 HPS_INLINE Vector_3D<F> const Point_3D<F>::operator- (Point_3D<F> const & p) const { return Vector_3D<F> (x - p.x, y - p.y, z - p.z); }
2842 
2843 template <typename F>
2844 HPS_INLINE Point_3D<F> const Point_3D<F>::operator+ (Vector_3D<F> const & v) const { return Point_3D<F> (x + v.x, y + v.y, z + v.z); }
2845 template <typename F>
2846 HPS_INLINE Point_3D<F> const Point_3D<F>::operator- (Vector_3D<F> const & v) const { return Point_3D<F> (x - v.x, y - v.y, z - v.z); }
2847 
2848 template <typename F>
2849 HPS_INLINE Point_3D<F> & Point_3D<F>::operator*= (Vector_3D<F> const & v) { x *= v.x; y *= v.y; z *= v.z; return *this; }
2850 template <typename F>
2851 HPS_INLINE Point_3D<F> & Point_3D<F>::operator/= (Vector_3D<F> const & v) { x /= v.x; y /= v.y; z /= v.z; return *this; }
2852 template <typename F>
2853 HPS_INLINE Point_3D<F> const Point_3D<F>::operator* (Vector_3D<F> const & v) const { return Point_3D<F> (x * v.x, y * v.y, z * v.z); }
2854 template <typename F>
2855 HPS_INLINE Point_3D<F> const Point_3D<F>::operator/ (Vector_3D<F> const & v) const { return Point_3D<F> (x / v.x, y / v.y, z / v.z); }
2856 
2857 
2858 
2859 template <typename F>
2860 HPS_INLINE Point_3D<F> Interpolate(Point_3D<F> const & a, Point_3D<F> const & b, float t) {
2861  return a + (b - a) * t;
2862 }
2863 
2864 template <typename F>
2865 HPS_INLINE Vector_3D<F> Interpolate(Vector_3D<F> const & a, Vector_3D<F> const & b, float t) {
2866  return Vector_3D<F>(a + (b - a) * t).Normalize();
2867 }
2868 
2869 
2870 
2871 template <typename F>
2872 HPS_INLINE double PointToPointDistance(Point_3D<F> const & p1, Point_3D<F> const & p2) {
2873  return (p2 - p1).Length();
2874 }
2875 
2876 template <typename F>
2877 HPS_INLINE double PointToPointDistanceSquared(Point_3D<F> const & p1, Point_3D<F> const & p2) {
2878  return (p2 - p1).LengthSquared();
2879 }
2880 
2881 template <typename F>
2882 HPS_INLINE Point_3D<F> Circumcenter(Point_3D<F> const & a, Point_3D<F> const & b, Point_3D<F> const & c) {
2883  F p = static_cast<F>((c - b).LengthSquared());
2884  F q = static_cast<F>((c - a).LengthSquared());
2885  F r = static_cast<F>((b - a).LengthSquared());
2886 
2887  return Point_3D<F>(
2888  (a * (p*(q+r-p)) + (Vector_3D<F>)b * (q*(r+p-q)) + (Vector_3D<F>)c * (r*(p+q-r)))
2889  / (2 * (p*q + p*r + q*r) - (p*p + q*q + r*r)) );
2890 }
2891 
2892 
2893 
2894 template <typename F>
2895 HPS_INLINE bool Normalize(size_t count, Vector_3D<F> * vectors) {
2896  bool success = true;
2897  for (size_t i = 0; i < count; ++i) {
2898  if (vectors->Normalize() == Vector_3D<F>::Zero())
2899  success = false;
2900  vectors++;
2901  }
2902  return success;
2903 }
2904 
2905 
2906 template <typename F> class HPS_TEMPLATE_API Plane_2D;
2907 
2908 template <typename F>
2909 class HPS_TEMPLATE_API Vector_2D {
2910 public:
2911  F x;
2912  F y;
2913 
2914  Vector_2D () {}
2915  Vector_2D (F v1, F v2) : x (v1), y (v2) {}
2916  template <typename D>
2917  explicit Vector_2D (Vector_2D<D> const & that) : x ((F)that.x), y ((F)that.y) {}
2918 
2919  explicit Vector_2D (Vector_3D<F> const & that) : x (that.x), y (that.y) {}
2920  explicit Vector_2D (Point_2D<F> const & p) : x(p.x), y(p.y) {}
2921  explicit Vector_2D (Plane_2D<F> const & p);
2922 
2923  Vector_2D const operator- () const { return Vector_2D (-x, -y); }
2924 
2925  bool operator== (Vector_2D const & v) const {
2926  return Float::match(x, v.x) && Float::match(y, v.y);
2927  }
2928  bool operator!= (Vector_2D const & v) const { return !(*this == v); }
2929 
2930  bool Equals(Vector_2D const & v, int in_tolerance = 32) const {
2931  return Float::Equals(x, v.x, in_tolerance) && Float::Equals(y, v.y, in_tolerance);
2932  }
2933 
2934  Vector_2D & operator+= (Vector_2D const & v) { x += v.x; y += v.y; return *this; }
2935  Vector_2D & operator-= (Vector_2D const & v) { x -= v.x; y -= v.y; return *this; }
2936  Vector_2D const operator+ (Vector_2D const & v) const { return Vector_2D (x + v.x, y + v.y); }
2937  Vector_2D const operator- (Vector_2D const & v) const { return Vector_2D (x - v.x, y - v.y); }
2938 
2939  Vector_2D & operator*= (F s) { x *= s; y *= s; return *this; }
2940  Vector_2D & operator/= (F s) { return operator*= (1.0f / s); }
2941  Vector_2D const operator* (F s) const { return Vector_2D (x * s, y * s); }
2942  Vector_2D const operator/ (F s) const { return operator* (1.0f / s); }
2943 
2944  F & operator[] (size_t i) { return (&x)[i]; }
2945  F const & operator[] (size_t i) const { return (&x)[i]; }
2946 
2947  HPS_INLINE double Length () const { return sqrt (LengthSquared()); }
2948 
2949  HPS_INLINE double LengthSquared () const { return (double)x*(double)x + (double)y*(double)y; }
2950 
2951  HPS_INLINE Vector_2D & Normalize (bool check_range = false, F epsilon = Float_Traits<F>::Epsilon()) {// not const &; allow V.normalize() *= S;
2952  if (check_range) {
2953  F range = Max (Abs (x), Abs (y));
2954  if (range > F(1.0e10))
2955  operator/= (range);
2956  }
2957 
2958  F len = (F)Length();
2959  if (len > epsilon)
2960  operator/= (len);
2961  else
2962  *this = Zero();
2963  return *this;
2964  }
2965  HPS_INLINE Vector_2D & Normalize (F epsilon) { return Normalize (false, epsilon); }
2966 
2967  HPS_INLINE F Magnitude () const { return Max (Abs(x), Abs(y)); }
2968  HPS_INLINE F Manhattan () const { return Abs(x)+Abs(y); }
2969 
2970  HPS_INLINE F Dot (Vector_2D const & v) const { return x * v.x + y * v.y; }
2971 
2972 
2973  HPS_INLINE float Cross (Vector_2D const & v) const {
2974  return x * v.y - y * v.x;
2975  }
2976 
2977  HPS_INLINE Vector_2D Scale (Vector_2D const & v) const {
2978  return Vector_2D (x * v.x, y * v.y);
2979  }
2980 
2981  static HPS_INLINE Vector_2D XAxis() {return Vector_2D (1, 0);};
2982  static HPS_INLINE Vector_2D YAxis() {return Vector_2D (0, 1);};
2983 
2984  static HPS_INLINE Vector_2D Zero() {return Vector_2D (0, 0);};
2985  static HPS_INLINE Vector_2D Unit() {return Vector_2D (1, 1);};
2986 };
2987 
2988 typedef Vector_2D<float> Vector2D;
2990 
2991 template <typename F, typename S>
2992 HPS_INLINE Vector_2D<F> operator* (S s, Vector_2D<F> const & v) {return Vector_2D<F> (F(s * v.x), F(s * v.y)); }
2993 
2994 template <typename F>
2995 HPS_INLINE bool Is_Abnormal (Vector_2D<F> const & v) {
2996  return Is_Abnormal (v.x) || Is_Abnormal (v.y);
2997 }
2998 
2999 
3000 template <typename F>
3001 HPS_INLINE Vector_3D<F>::Vector_3D (Vector_2D<F> const & that) : x (that.x), y (that.y), z(0) {}
3002 
3003 template <typename F>
3004 HPS_INLINE Point_3D<F>::Point_3D(Vector_2D<F> const & v) : x(v.x), y(v.y), z(0) {}
3005 
3006 template <typename F>
3007 HPS_INLINE Point_3D<F> & Point_3D<F>::operator+= (Vector_2D<F> const & v) { x += v.x; y += v.y; return *this; }
3008 template <typename F>
3009 HPS_INLINE Point_3D<F> & Point_3D<F>::operator-= (Vector_2D<F> const & v) { x -= v.x; y -= v.y; return *this; }
3010 
3011 template <typename F>
3012 HPS_INLINE Point_3D<F> const Point_3D<F>::operator+ (Vector_2D<F> const & v) const { return Point_3D<F> (x + v.x, y + v.y, z); }
3013 template <typename F>
3014 HPS_INLINE Point_3D<F> const Point_3D<F>::operator- (Vector_2D<F> const & v) const { return Point_3D<F> (x - v.x, y - v.y, z); }
3015 
3016 template <typename F>
3017 HPS_INLINE Point_3D<F> & Point_3D<F>::operator*= (Vector_2D<F> const & v) { x *= v.x; y *= v.y; return *this; }
3018 template <typename F>
3019 HPS_INLINE Point_3D<F> & Point_3D<F>::operator/= (Vector_2D<F> const & v) { x /= v.x; y /= v.y; return *this; }
3020 
3021 template <typename F>
3022 HPS_INLINE Point_3D<F> const Point_3D<F>::operator* (Vector_2D<F> const & v) const { return Point_3D<F> (x * v.x, y * v.y, z); }
3023 template <typename F>
3024 HPS_INLINE Point_3D<F> const Point_3D<F>::operator/ (Vector_2D<F> const & v) const { return Point_3D<F> (x / v.x, y / v.y, z); }
3025 
3026 
3027 template <typename F>
3028 HPS_INLINE Point_2D<F> & Point_2D<F>::operator+= (Vector_2D<F> const & v) { x += v.x; y += v.y; return *this; }
3029 template <typename F>
3030 HPS_INLINE Point_2D<F> & Point_2D<F>::operator-= (Vector_2D<F> const & v) { x -= v.x; y -= v.y; return *this; }
3031 
3032 template <typename F>
3033 HPS_INLINE Vector_2D<F> const Point_2D<F>::operator- (Point_2D<F> const & p) const { return Vector_2D<F> (x - p.x, y - p.y); }
3034 
3035 template <typename F>
3036 HPS_INLINE Point_2D<F> const Point_2D<F>::operator+ (Vector_2D<F> const & v) const { return Point_2D<F> (x + v.x, y + v.y); }
3037 template <typename F>
3038 HPS_INLINE Point_2D<F> const Point_2D<F>::operator- (Vector_2D<F> const & v) const { return Point_2D<F> (x - v.x, y - v.y); }
3039 
3040 template <typename F>
3041 HPS_INLINE Point_2D<F> & Point_2D<F>::operator*= (Vector_2D<F> const & v) { x *= v.x; y *= v.y; return *this; }
3042 template <typename F>
3043 HPS_INLINE Point_2D<F> & Point_2D<F>::operator/= (Vector_2D<F> const & v) { x /= v.x; y /= v.y; return *this; }
3044 template <typename F>
3045 HPS_INLINE Point_2D<F> const Point_2D<F>::operator* (Vector_2D<F> const & v) const { return Point_2D<F> (x * v.x, y * v.y); }
3046 template <typename F>
3047 HPS_INLINE Point_2D<F> const Point_2D<F>::operator/ (Vector_2D<F> const & v) const { return Point_2D<F> (x / v.x, y / v.y); }
3048 
3049 
3050 
3051 
3052 
3053 template <typename F>
3054 class HPS_TEMPLATE_API Plane_3D {
3055  public:
3056  F a;
3057  F b;
3058  F c;
3059  F d;
3060 
3061  Plane_3D () {}
3062  Plane_3D (F v1, F v2, F v3, F v4) : a (v1), b (v2), c (v3), d (v4) {}
3063  Plane_3D (Vector_3D<F> const & v, F f = 0) : a (v.x), b (v.y), c (v.z), d (f) {}
3064  Plane_3D (Vector_3D<F> const & v, Point_3D<F> const & p) : a (v.x), b (v.y), c (v.z), d (-(p.x * v.x + p.y * v.y + p.z * v.z)) {}
3065  Plane_3D (Point_3D<F> const & p, Vector_3D<F> const & v) : a (v.x), b (v.y), c (v.z), d (-(p.x * v.x + p.y * v.y + p.z * v.z)) {}
3066  template <typename D>
3067  explicit Plane_3D (Plane_3D<D> const & that) : a ((F)that.a), b ((F)that.b), c ((F)that.c), d ((F)that.d) {}
3068 
3069  Plane_3D (size_t count, Point_3D<F> const * points) {
3070  if (count >= 3) {
3071  // The 3 coefficients A, B, and C are proportional to the areas of the
3072  // projections of the polygon onto the yz, zx, and xy planes, respectively.
3073 
3074  // run around the polygon, collecting trapezoidal areas
3075  // a "center" point is also collected, to make the plane 'd' slightly more "valid" when the polygon is non-planar.
3076 
3077  // take care of the swing point first
3078  Point_3D<F> const * p0 = &points[count-1];
3079 
3081  Vector_3D<F> normal = Vector_3D<F>::Zero();
3082 
3083  for (size_t i=0; i<count; ++i) {
3084  Point_3D<F> const * p1 = &points[i];
3085 
3086  normal.x += (p0->y + p1->y) * (p1->z - p0->z);
3087  normal.y += (p0->z + p1->z) * (p1->x - p0->x);
3088  normal.z += (p0->x + p1->x) * (p1->y - p0->y);
3089 
3090  ctr += Vector_3D<double>(Vector_3D<F>(points[i]));
3091 
3092  p0 = p1;
3093  }
3094 
3095  // ("should" always be != 0)
3096  if (normal.Normalize() != Vector_3D<F>::Zero()) {
3097  /* finish finding the average */
3098  double inv_count = 1.0 / (double)count;
3099  ctr *= inv_count;
3100 
3101  *this = Plane_3D(normal, Point_3D<F>(ctr));
3102  return;
3103  }
3104  }
3105 
3106  *this = Plane_3D::Zero();
3107  }
3108 
3109 
3110  Plane_3D const operator- () const { return Plane_3D (-a, -b, -c, -d); }
3111 
3112  bool operator== (Plane_3D const & p) const { return a == p.a && b == p.b && c == p.c && d == p.d; }
3113  bool operator!= (Plane_3D const & p) const { return !(*this == p); }
3114 
3115  F & operator[] (size_t i) { return (&a)[i]; }
3116  F const & operator[] (size_t i) const { return (&a)[i]; }
3117 
3118  HPS_INLINE bool Equals(Plane_3D const & p, int in_tolerance = 32) const {
3119  return Float::Equals(a, p.a, in_tolerance) && Float::Equals(b, p.b, in_tolerance) &&
3120  Float::Equals(c, p.c, in_tolerance) && Float::Equals(d, p.d, in_tolerance);
3121  }
3122 
3123  Plane_3D & Normalize (F epsilon = Float_Traits<F>::Epsilon()) { // not const &; allow V.normalize() *= S;
3124  F len = (F)Vector_3D<F>(*this).Length();
3125  if (len > epsilon)
3126  operator/= (len);
3127  else
3128  *this = Zero();
3129  return *this;
3130  }
3131 
3132  Point_3D<F> IntersectLineSegment(Point_3D<F> const & p1, Point_3D<F> const & p2, float eps = 1e-5f) const {
3133  F val1 = Abs (a * p1.x + b * p1.y + c * p1.z + d);
3134  F val2 = Abs (a * p2.x + b * p2.y + c * p2.z + d);
3135 
3136  if (val1 >= eps) {
3137  return Point_3D<F> (((val1 * p2.x) + (val2 * p1.x)) / (val1 + val2),
3138  ((val1 * p2.y) + (val2 * p1.y)) / (val1 + val2),
3139  ((val1 * p2.z) + (val2 * p1.z)) / (val1 + val2));
3140  }
3141  else
3142  return p1;
3143  }
3144 
3145  Point_3D<F> IntersectLineSegment2(Point_3D<F> const & p1, Point_3D<F> const & p2) const {
3146  F u = (a * p1.x + b * p1.y + c * p1.z + d) /
3147  (a * (p1.x - p2.x) + b * (p1.y - p2.y) + c * (p1.z - p2.z));
3148 
3149  return Point_3D<F>(p1.x + u * (p2.x - p1.x), p1.y + u * (p2.y - p1.y), p1.z + u * (p2.z - p1.z));
3150  }
3151 
3152  static HPS_INLINE Plane_3D Zero() {return Plane_3D (0.0f, 0.0f, 0.0f, 0.0f);};
3153 
3154 
3155  private:
3156  Plane_3D & operator*= (F s) { a *= s; b *= s; c *= s; d *= s; return *this; }
3157  Plane_3D & operator/= (F s) { return operator*= ((F)1.0 / s); }
3158  Plane_3D const operator* (F s) const { return Plane_3D (a * s, b * s, c * s, d * s); }
3159  Plane_3D const operator/ (F s) const { return operator* ((F)1.0 / s); }
3160 };
3161 
3162 typedef Plane_3D<float> Plane;
3163 typedef Plane_3D<double> DPlane;
3164 
3165 
3166 template <typename F>
3167 HPS_INLINE bool Is_Abnormal (Plane_3D<F> const & p) {
3168  return Is_Abnormal (p.a) || Is_Abnormal (p.b) || Is_Abnormal (p.c) || Is_Abnormal (p.d);
3169 }
3170 
3171 
3172 template <typename F>
3173 HPS_INLINE F operator* (Plane_3D<F> const & plane, Point_3D<F> const & point) {
3174  return plane.a * point.x + plane.b * point.y + plane.c * point.z + plane.d;
3175 }
3176 template <typename F>
3177 HPS_INLINE F operator* (Point_3D<F> const & point, Plane_3D<F> const & plane) {
3178  return plane * point;
3179 }
3180 
3181 template <typename F>
3182 HPS_INLINE Plane_3D<F> Interpolate(Plane_3D<F> const & a, Plane_3D<F> const & b, float t) {
3183  return Plane_3D<F>(a.a + (b.a - a.a) * t, a.b + (b.b - a.b) * t, a.c + (b.c - a.c) * t, a.d + (b.d - a.d) * t);
3184 }
3185 
3186 template <typename F>
3187 Vector_3D<F>::Vector_3D(Plane_3D<F> const & p) : x(p.a), y(p.b), z(p.c) {}
3188 
3189 
3190 
3191 
3192 
3193 
3194 template <typename F>
3195 class HPS_TEMPLATE_API Plane_2D {
3196 public:
3197  F a;
3198  F b;
3199  F c;
3200 
3201  Plane_2D () {}
3202  Plane_2D (F v1, F v2, F v3) : a (v1), b (v2), c (v3) {}
3203  Plane_2D (Vector_2D<F> const & v, F f = 0) : a (v.x), b (v.y), c (f) {}
3204  Plane_2D (Vector_2D<F> const & v, Point_2D<F> const & p) : a (v.x), b (v.y), c (-(p.x * v.x + p.y * v.y)) {}
3205  Plane_2D (Point_2D<F> const & p, Vector_2D<F> const & v) : a (v.x), b (v.y), c (-(p.x * v.x + p.y * v.y)) {}
3206  template <typename D>
3207  explicit Plane_2D (Plane_2D<D> const & that) : a ((F)that.a), b ((F)that.b), c ((F)that.c) {}
3208 
3209  Plane_2D const operator- () const { return Plane_2D (-a, -b, -c); }
3210 
3211  bool operator== (Plane_2D const & p) const { return a == p.a && b == p.b && c == p.c; }
3212  bool operator!= (Plane_2D const & p) const { return !(*this == p); }
3213 
3214  F & operator[] (size_t i) { return (&a)[i]; }
3215  F const & operator[] (size_t i) const { return (&a)[i]; }
3216 
3217  HPS_INLINE bool Equals(Plane_2D const & p, int in_tolerance = 32) const {
3218  return Float::Equals(a, p.a, in_tolerance) && Float::Equals(b, p.b, in_tolerance) && Float::Equals(c, p.c, in_tolerance);
3219  }
3220 
3221  Plane_2D & Normalize (F epsilon = Float_Traits<F>::Epsilon()) { // not const &; allow V.Normalize() *= S;
3222  F len = (F)Vector_2D<F>(*this).Length();
3223  if (len > epsilon)
3224  operator/= (len);
3225  else
3226  *this = Zero();
3227  return *this;
3228  }
3229 
3230  static HPS_INLINE Plane_2D Zero() {return Plane_2D (0.0f, 0.0f, 0.0f);};
3231 
3232 
3233 private:
3234  Plane_2D & operator*= (F s) { a *= s; b *= s; c *= s; return *this; }
3235  Plane_2D & operator/= (F s) { return operator*= ((F)1.0 / s); }
3236  Plane_2D const operator* (F s) const { return Plane_2D (a * s, b * s, c * s); }
3237  Plane_2D const operator/ (F s) const { return operator* ((F)1.0 / s); }
3238 };
3239 
3240 typedef Plane_2D<float> Plane2D;
3241 typedef Plane_2D<double> DPlane2D;
3242 
3243 
3244 template <typename F>
3245 HPS_INLINE bool Is_Abnormal (Plane_2D<F> const & p) {
3246  return Is_Abnormal (p.a) || Is_Abnormal (p.b) || Is_Abnormal (p.c);
3247 }
3248 
3249 
3250 template <typename F>
3251 HPS_INLINE F operator* (Plane_2D<F> const & plane, Point_2D<F> const & point) {
3252  return plane.a * point.x + plane.b * point.y + plane.c;
3253 }
3254 template <typename F>
3255 HPS_INLINE F operator* (Point_3D<F> const & point, Plane_2D<F> const & plane) {
3256  return plane * point;
3257 }
3258 
3259 template <typename F>
3260 HPS_INLINE Plane_2D<F> Interpolate(Plane_2D<F> const & a, Plane_2D<F> const & b, float t) {
3261  return Plane_2D<F>(a.a + (b.a - a.a) * t, a.b + (b.b - a.b) * t, a.c + (b.c - a.c) * t);
3262 }
3263 
3264 template <typename F>
3265 Vector_2D<F>::Vector_2D(Plane_2D<F> const & p) : x(p.a), y(p.b) {}
3266 
3267 
3268 
3269 
3270 struct Rectangle;
3271 
3272 struct HPS_API IntRectangle {
3273  int left;
3274  int right;
3275  int bottom;
3276  int top;
3277 
3278  IntRectangle()
3279  : left(std::numeric_limits<int>::max()), right(std::numeric_limits<int>::min()),
3280  bottom(std::numeric_limits<int>::max()), top(std::numeric_limits<int>::min()) {}
3281 
3282  IntRectangle(int in_left, int in_right, int in_bottom, int in_top)
3283  : left(in_left), right(in_right), bottom(in_bottom), top(in_top) {}
3284 
3285  IntRectangle(IntRectangle const & that)
3286  : left(that.left), right(that.right), bottom(that.bottom), top(that.top) {}
3287 
3288  explicit IntRectangle(Rectangle const & that);
3289 
3290  bool operator==(IntRectangle const & rect) const {
3291  return (left == rect.left && right == rect.right && bottom == rect.bottom && top == rect.top);
3292  }
3293 
3294  bool operator!=(IntRectangle const & rect) const {
3295  return !(*this == rect);
3296  }
3297 
3298  HPS_INLINE int PixelWidth() const {
3299  return right - left + 1;
3300  }
3301 
3302  HPS_INLINE int PixelHeight() const {
3303  return top - bottom + 1;
3304  }
3305 
3306  HPS_INLINE int Width() const {
3307  return right - left;
3308  }
3309 
3310  HPS_INLINE int Height() const {
3311  return top - bottom;
3312  }
3313 
3314  HPS_INLINE int Area() const {
3315  return Width() * Height();
3316  }
3317 
3318  HPS_INLINE Point2D Center() const {
3319  return Point2D((float)(left + right) * 0.5f, (float)(bottom + top) * 0.5f);
3320  }
3321 
3322  HPS_INLINE bool Intersecting(IntRectangle const & rect) const {
3323  return right >= rect.left && left <= rect.right && top >= rect.bottom && bottom <= rect.top;
3324  }
3325 
3326  HPS_INLINE bool Contains(IntRectangle const & rect) const {
3327  return (left <= rect.left && right >= rect.right && bottom <= rect.bottom && top >= rect.top);
3328  }
3329 
3330  HPS_INLINE IntRectangle & Expand(int border) {
3331  left -= border;
3332  right += border;
3333  bottom -= border;
3334  top += border;
3335  return *this;
3336  }
3337 
3338  HPS_INLINE IntRectangle & Expand(IntRectangle const & rect) {
3339  left -= rect.left;
3340  right += rect.right;
3341  bottom -= rect.bottom;
3342  top += rect.top;
3343  return *this;
3344  }
3345 
3346  HPS_INLINE IntRectangle & Contract(int border) {
3347  left += border;
3348  right -= border;
3349  bottom += border;
3350  top -= border;
3351  return *this;
3352  }
3353 
3354  HPS_INLINE IntRectangle & Contract(IntRectangle const & rect) {
3355  left += rect.left;
3356  right -= rect.right;
3357  bottom += rect.bottom;
3358  top -= rect.top;
3359  return *this;
3360  }
3361 
3362  HPS_INLINE IntRectangle & Intersect(IntRectangle const & rect) {
3363  left = Max(left, rect.left);
3364  right = Min(right, rect.right);
3365  bottom = Max(bottom, rect.bottom);
3366  top = Min(top, rect.top);
3367  return *this;
3368  }
3369 
3370  HPS_INLINE IntRectangle & Union(IntRectangle const & rect) {
3371  left = Min(left, rect.left);
3372  right = Max(right, rect.right);
3373  bottom = Min(bottom, rect.bottom);
3374  top = Max(top, rect.top);
3375  return *this;
3376  }
3377 
3378 
3379  static HPS_INLINE IntRectangle Invalid() {
3380  return IntRectangle();
3381  }
3382 
3383  static HPS_INLINE IntRectangle Zero() {
3384  return IntRectangle(0, 0, 0, 0);
3385  }
3386 
3387 };
3388 
3389 HPS_INLINE IntRectangle Expand(IntRectangle const & a, IntRectangle const & border) {
3390  IntRectangle temp = a;
3391  return temp.Expand(border);
3392 }
3393 
3394 HPS_INLINE IntRectangle Expand(IntRectangle const & a, int border) {
3395  IntRectangle temp = a;
3396  return temp.Expand(border);
3397 }
3398 
3399 HPS_INLINE IntRectangle Contract(IntRectangle const & a, int border) {
3400  IntRectangle temp = a;
3401  return temp.Contract(border);
3402 }
3403 
3404 HPS_INLINE IntRectangle Contract(IntRectangle const & a, IntRectangle const & border) {
3405  IntRectangle temp = a;
3406  return temp.Contract(border);
3407 }
3408 
3409 HPS_INLINE IntRectangle Intersect(IntRectangle const & a, IntRectangle const & b) {
3410  IntRectangle temp = a;
3411  return temp.Intersect(b);
3412 }
3413 
3414 HPS_INLINE IntRectangle Union(IntRectangle const & a, IntRectangle const & b) {
3415  IntRectangle temp = a;
3416  return temp.Union(b);
3417 }
3418 
3419 struct HPS_API Rectangle {
3420  float left;
3421  float right;
3422  float bottom;
3423  float top;
3424 
3425  Rectangle()
3426  : left(std::numeric_limits<float>::max()), right(std::numeric_limits<float>::min()),
3427  bottom(std::numeric_limits<float>::max()), top(std::numeric_limits<float>::min()) {}
3428 
3429  Rectangle(float in_left, float in_right, float in_bottom, float in_top)
3430  : left(in_left), right(in_right), bottom(in_bottom), top(in_top) {}
3431 
3432  Rectangle(Rectangle const & that)
3433  : left(that.left), right(that.right), bottom(that.bottom), top(that.top) {}
3434 
3435  explicit Rectangle(IntRectangle const & that)
3436  : left((float)that.left), right((float)that.right), bottom((float)that.bottom), top((float)that.top) {}
3437 
3438  HPS_INLINE Rectangle(size_t count, Point const * points) {
3439  left = points->x;
3440  right = points->x;
3441  top = points->y;
3442  bottom = points->y;
3443  --count;
3444  if (count > 0) {
3445  ++points;
3446  Merge(count, points);
3447  }
3448  }
3449 
3450  HPS_INLINE Rectangle(size_t count, Point2D const * points) {
3451  left = points->x;
3452  right = points->x;
3453  top = points->y;
3454  bottom = points->y;
3455  --count;
3456  if (count > 0) {
3457  ++points;
3458  Merge(count, points);
3459  }
3460  }
3461 
3462  HPS_INLINE float Width() const {
3463  return right - left;
3464  }
3465 
3466  HPS_INLINE float Height() const {
3467  return top - bottom;
3468  }
3469 
3470  HPS_INLINE float Area() const {
3471  return Width() * Height();
3472  }
3473 
3474  HPS_INLINE Point2D Center() const {
3475  return Point2D((left + right) * 0.5f, (bottom + top) * 0.5f);
3476  }
3477 
3478  HPS_INLINE void Merge(size_t count, Point const * points) {
3479 
3480  while (count > 1) {
3481  if (Compare(points[0].x, points[1].x)>0) {
3482  Float::replace_if_smaller(left, points[1].x);
3483  Float::replace_if_larger(right, points[0].x);
3484  }
3485  else {
3486  Float::replace_if_smaller(left, points[0].x);
3487  Float::replace_if_larger(right, points[1].x);
3488  }
3489 
3490  if (Compare(points[0].y, points[1].y)>0) {
3491  Float::replace_if_smaller(bottom, points[1].y);
3492  Float::replace_if_larger(top, points[0].y);
3493  }
3494  else {
3495  Float::replace_if_smaller(bottom, points[0].y);
3496  Float::replace_if_larger(top, points[1].y);
3497  }
3498 
3499  points += 2;
3500  count -= 2;
3501  }
3502 
3503  if (count > 0)
3504  Merge(*points);
3505  }
3506 
3507  HPS_INLINE void Merge(Point const & point) {
3508  Float::replace_if_smaller(left, point.x);
3509  Float::replace_if_smaller(bottom, point.y);
3510  Float::replace_if_larger(right, point.x);
3511  Float::replace_if_larger(top, point.y);
3512  }
3513 
3514  HPS_INLINE void Merge(size_t count, Point2D const * points) {
3515 
3516  while (count > 1) {
3517  if (Compare(points[0].x, points[1].x)>0) {
3518  Float::replace_if_smaller(left, points[1].x);
3519  Float::replace_if_larger(right, points[0].x);
3520  }
3521  else {
3522  Float::replace_if_smaller(left, points[0].x);
3523  Float::replace_if_larger(right, points[1].x);
3524  }
3525 
3526  if (Compare(points[0].y, points[1].y)>0) {
3527  Float::replace_if_smaller(bottom, points[1].y);
3528  Float::replace_if_larger(top, points[0].y);
3529  }
3530  else {
3531  Float::replace_if_smaller(bottom, points[0].y);
3532  Float::replace_if_larger(top, points[1].y);
3533  }
3534 
3535  points += 2;
3536  count -= 2;
3537  }
3538 
3539  if (count > 0)
3540  Merge(*points);
3541  }
3542 
3543  HPS_INLINE void Merge(Point2D const & point) {
3544  Float::replace_if_smaller(left, point.x);
3545  Float::replace_if_smaller(bottom, point.y);
3546  Float::replace_if_larger(right, point.x);
3547  Float::replace_if_larger(top, point.y);
3548  }
3549 
3550  bool operator==(Rectangle const & rect) const {
3551  return (left == rect.left && right == rect.right && bottom == rect.bottom && top == rect.top);
3552  }
3553 
3554  bool operator!=(Rectangle const & rect) const {
3555  return !(*this == rect);
3556  }
3557 
3558  HPS_INLINE bool Intersecting(Rectangle const & rect) const {
3559  return right >= rect.left && left <= rect.right && top >= rect.bottom && bottom <= rect.top;
3560  }
3561 
3562  HPS_INLINE bool Contains(Point const & contained) const {
3563  return !(contained.x < left || contained.x > right || contained.y < bottom || contained.y > top);
3564  }
3565 
3566  HPS_INLINE bool Contains(Point2D const & contained) const {
3567  return !(contained.x < left || contained.x > right || contained.y < bottom || contained.y > top);
3568  }
3569 
3570  HPS_INLINE bool Contains(Rectangle const & rect) {
3571  return (left <= rect.left && right >= rect.right && bottom <= rect.bottom && top >= rect.top);
3572  }
3573 
3574  HPS_INLINE bool Contains(Rectangle const & rect, float epsilon) {
3575  return (left <= rect.left + epsilon && right >= rect.right - epsilon &&
3576  bottom <= rect.bottom + epsilon && top >= rect.top - epsilon);
3577  }
3578 
3579  HPS_INLINE Rectangle & Expand(float border) {
3580  left -= border;
3581  right += border;
3582  bottom -= border;
3583  top += border;
3584  return *this;
3585  }
3586 
3587  HPS_INLINE Rectangle & Expand(int border) {
3588  Expand((float)border);
3589  return *this;
3590  }
3591 
3592  HPS_INLINE Rectangle & Expand(Rectangle const & rect) {
3593  left -= rect.left;
3594  right += rect.right;
3595  bottom -= rect.bottom;
3596  top += rect.top;
3597  return *this;
3598  }
3599 
3600  HPS_INLINE Rectangle & Contract(int border) {
3601  left += border;
3602  right -= border;
3603  bottom += border;
3604  top -= border;
3605  return *this;
3606  }
3607 
3608  HPS_INLINE Rectangle & Contract(Rectangle const & rect) {
3609  left += rect.left;
3610  right -= rect.right;
3611  bottom += rect.bottom;
3612  top -= rect.top;
3613  return *this;
3614  }
3615 
3616  HPS_INLINE Rectangle & Intersect(Rectangle const & rect) {
3617  left = Max(left, rect.left);
3618  right = Min(right, rect.right);
3619  bottom = Max(bottom, rect.bottom);
3620  top = Min(top, rect.top);
3621  return *this;
3622  }
3623 
3624  HPS_INLINE Rectangle & Union(Rectangle const & rect) {
3625  left = Min(left, rect.left);
3626  right = Max(right, rect.right);
3627  bottom = Min(bottom, rect.bottom);
3628  top = Max(top, rect.top);
3629  return *this;
3630  }
3631 
3632  HPS_INLINE Rectangle & Inscribe_Scope(Rectangle const & scope) {
3633  float scale = (scope.right - scope.left) * 0.5f;
3634  float trans = (scope.right + scope.left) * 0.5f;
3635 
3636  left = left * scale + trans;
3637  right = right * scale + trans;
3638 
3639  scale = (scope.top - scope.bottom) * 0.5f;
3640  trans = (scope.top + scope.bottom) * 0.5f;
3641 
3642  bottom = bottom * scale + trans;
3643  top = top * scale + trans;
3644  return *this;
3645  }
3646 
3647  HPS_INLINE Rectangle & Circumscribe_Scope(Rectangle const & scope) {
3648  float tmp = 2.0f/(scope.right - scope.left);
3649  right = (right - scope.left) * tmp - 1.0f;
3650  left = (left - scope.left) * tmp - 1.0f;
3651 
3652  tmp = 2.0f/(scope.top - scope.bottom);
3653  top = (top - scope.bottom) * tmp - 1.0f;
3654  bottom = (bottom - scope.bottom) * tmp - 1.0f;
3655  return *this;
3656  }
3657 
3658  static HPS_INLINE Rectangle FullScope() {
3659  return Rectangle(-1.0f, 1.0f, -1.0f, 1.0f);
3660  }
3661 
3662  static HPS_INLINE Rectangle InvalidScope() {
3663  return Rectangle(1.0f, -1.0f, 1.0f, -1.0f);
3664  }
3665 
3666  static HPS_INLINE Rectangle Zero() {
3667  return Rectangle(0, 0, 0, 0);
3668  }
3669 
3670 };
3671 
3672 
3673 HPS_INLINE IntRectangle Floor(Rectangle const & a) {
3674  IntRectangle temp;
3675  temp.left = Floor (a.left);
3676  temp.right = Floor (a.right);
3677  temp.bottom = Floor (a.bottom);
3678  temp.top = Floor (a.top);
3679  return temp;
3680 }
3681 
3682 HPS_INLINE Rectangle Expand(Rectangle const & a, Rectangle const & border) {
3683  Rectangle temp = a;
3684  return temp.Expand(border);
3685 }
3686 
3687 HPS_INLINE Rectangle Expand(Rectangle const & a, float border) {
3688  Rectangle temp = a;
3689  return temp.Expand(border);
3690 }
3691 
3692 HPS_INLINE Rectangle Contract(Rectangle const & a, int border) {
3693  Rectangle temp = a;
3694  return temp.Contract(border);
3695 }
3696 
3697 HPS_INLINE Rectangle Contract(Rectangle const & a, Rectangle const & border) {
3698  Rectangle temp = a;
3699  return temp.Contract(border);
3700 }
3701 
3702 HPS_INLINE Rectangle Intersect(Rectangle const & a, Rectangle const & b) {
3703  Rectangle temp = a;
3704  return temp.Intersect(b);
3705 }
3706 
3707 HPS_INLINE Rectangle Union(Rectangle const & a, Rectangle const & b) {
3708  Rectangle temp = a;
3709  return temp.Union(b);
3710 }
3711 
3712 HPS_INLINE Rectangle Inscribe_Scope(Rectangle const & a, Rectangle const & scope) {
3713  Rectangle temp = a;
3714  return temp.Inscribe_Scope(scope);
3715 }
3716 
3717 HPS_INLINE Rectangle Circumscribe_Scope(Rectangle const & a, Rectangle const & scope) {
3718  Rectangle temp = a;
3719  return temp.Circumscribe_Scope(scope);
3720 }
3721 
3722 HPS_INLINE IntRectangle::IntRectangle(Rectangle const & that)
3723  : left ((int)that.left), right ((int)that.right), bottom ((int)that.bottom), top ((int)that.top) {}
3724 
3725 
3726 
3727 
3728 template <typename F>
3729 struct Sphere_3D;
3730 
3731 template <typename F>
3732 struct HPS_TEMPLATE_API Cuboid_3D {
3737 
3738 
3742  Cuboid_3D () : min (Limit_Point()), max (-Limit_Point()) {}
3743 
3744  template <typename D>
3745 
3750  explicit Cuboid_3D (Cuboid_3D<D> const & that) : min (Point_3D<F>(that.min)), max (Point_3D<F>(that.max)) {}
3751 
3752 
3757  Cuboid_3D (Sphere_3D<F> const & that);
3758 
3764  Cuboid_3D (Point_3D<F> const & in_min, Point_3D<F> const & in_max) : min (in_min), max (in_max) {}
3765 
3771  Cuboid_3D (size_t count, Point_3D<F> const * points) {
3772  if (count == 0) {
3773  min = Limit_Point();
3774  max = -Limit_Point();
3775  return;
3776  }
3777  min = max = *points++;
3778  --count;
3779  if (count>0)
3780  Merge(count, points);
3781  }
3782 
3787  Cuboid_3D (Rectangle const & that) : min (Point_3D<F>(that.left, that.bottom, 0)), max (Point_3D<F>(that.right, that.top, 0)) {}
3788 
3792  HPS_INLINE bool IsValid() const {
3793  return min.x <= max.x && min.y <= max.y && min.z <= max.z;
3794  }
3795 
3799  static HPS_INLINE Cuboid_3D Invalid() {return Cuboid_3D ();};
3800 
3804  void Invalidate() {min = Limit_Point(); max = -Limit_Point();}
3805 
3810  HPS_INLINE bool operator== (Cuboid_3D const & cuboid) const { return (min == cuboid.min && max == cuboid.max); }
3811 
3816  HPS_INLINE bool operator!= (Cuboid_3D const & cuboid) const { return !(*this == cuboid); }
3817 
3822  HPS_INLINE void Generate_Cuboid_Points (Point_3D<F> * points) const {
3823  points[0] = Point_3D<F> (min.x, min.y, min.z);
3824  points[1] = Point_3D<F> (min.x, min.y, max.z);
3825  points[2] = Point_3D<F> (min.x, max.y, min.z);
3826  points[3] = Point_3D<F> (min.x, max.y, max.z);
3827  points[4] = Point_3D<F> (max.x, min.y, min.z);
3828  points[5] = Point_3D<F> (max.x, min.y, max.z);
3829  points[6] = Point_3D<F> (max.x, max.y, min.z);
3830  points[7] = Point_3D<F> (max.x, max.y, max.z);
3831  }
3832 
3836  HPS_INLINE Vector_3D<F> Diagonal() const { return max - min; }
3837 
3841  HPS_INLINE F Volume () const { return (max.x - min.x) * (max.y - min.y) * (max.z - min.z); }
3842 
3848  HPS_INLINE bool Intersecting (Cuboid_3D const & cuboid) const {
3849  return max.x >= cuboid.min.x && min.x <= cuboid.max.x &&
3850  max.y >= cuboid.min.y && min.y <= cuboid.max.y &&
3851  max.z >= cuboid.min.z && min.z <= cuboid.max.z;
3852  }
3853 
3859  HPS_INLINE bool Intersecting (Cuboid_3D const & cuboid, F const allowance) const {
3860  return max.x + allowance >= cuboid.min.x && min.x - allowance <= cuboid.max.x &&
3861  max.y + allowance >= cuboid.min.y && min.y - allowance <= cuboid.max.y &&
3862  max.z + allowance >= cuboid.min.z && min.z - allowance <= cuboid.max.z;
3863  }
3864 
3871  HPS_INLINE bool Intersecting (int dimension, Cuboid_3D const & cuboid) const {
3872  //ASSERT (0 <= dimension && dimension <= 2);
3873  return max[dimension] >= cuboid.min[dimension] && min[dimension] <= cuboid.max[dimension];
3874  }
3875 
3883  HPS_INLINE bool Intersecting (int dimension, Cuboid_3D const & cuboid, F const allowance) const {
3884  //ASSERT (0 <= dimension && dimension <= 2);
3885  return max[dimension] + allowance >= cuboid.min[dimension] && min[dimension] - allowance <= cuboid.max[dimension];
3886  }
3887 
3894  HPS_INLINE bool Intersecting (Point_3D<F> const & start, Vector_3D<F> const & direction) const {
3895  return LineIntersecting(start, direction, true);
3896  }
3897 
3904  HPS_INLINE bool Intersecting (Point_3D<F> const & point1, Point_3D<F> const & point2) const {
3905  Vector_3D<F> const direction = point2 - point1;
3906  return LineIntersecting(point1, direction, false);
3907  }
3908 
3914  HPS_INLINE void Merge(Cuboid_3D const & cuboid) {
3915  Float::replace_if_smaller(min.x, cuboid.min.x);
3916  Float::replace_if_smaller(min.y, cuboid.min.y);
3917  Float::replace_if_smaller(min.z, cuboid.min.z);
3918  Float::replace_if_larger(max.x, cuboid.max.x);
3919  Float::replace_if_larger(max.y, cuboid.max.y);
3920  Float::replace_if_larger(max.z, cuboid.max.z);
3921  }
3922 
3928  HPS_INLINE void Merge(Sphere_3D<F> const & sphere) { Merge (Cuboid_3D (sphere)); }
3929 
3935  HPS_INLINE void Merge(Point_3D<F> const & point) {
3936  Float::replace_if_smaller(min.x, point.x);
3937  Float::replace_if_smaller(min.y, point.y);
3938  Float::replace_if_smaller(min.z, point.z);
3939  Float::replace_if_larger(max.x, point.x);
3940  Float::replace_if_larger(max.y, point.y);
3941  Float::replace_if_larger(max.z, point.z);
3942  }
3943 
3950  void Merge(size_t count, Point_3D<F> const * points) {
3951  while (count > 1) {
3952  if (Compare(points[0].x, points[1].x)>0) {
3953  Float::replace_if_smaller(min.x, points[1].x);
3954  Float::replace_if_larger(max.x, points[0].x);
3955  }
3956  else {
3957  Float::replace_if_smaller(min.x, points[0].x);
3958  Float::replace_if_larger(max.x, points[1].x);
3959  }
3960 
3961  if (Compare(points[0].y, points[1].y)>0) {
3962  Float::replace_if_smaller(min.y, points[1].y);
3963  Float::replace_if_larger(max.y, points[0].y);
3964  }
3965  else {
3966  Float::replace_if_smaller(min.y, points[0].y);
3967  Float::replace_if_larger(max.y, points[1].y);
3968  }
3969 
3970  if (Compare(points[0].z, points[1].z)>0) {
3971  Float::replace_if_smaller(min.z, points[1].z);
3972  Float::replace_if_larger(max.z, points[0].z);
3973  }
3974  else {
3975  Float::replace_if_smaller(min.z, points[0].z);
3976  Float::replace_if_larger(max.z, points[1].z);
3977  }
3978 
3979  points += 2;
3980  count -= 2;
3981  }
3982 
3983  if (count > 0)
3984  Merge(*points);
3985  }
3986 
3992  HPS_INLINE bool Contains(Cuboid_3D const & contained) const {
3993  return (contained.min.x >= min.x &&
3994  contained.min.y >= min.y &&
3995  contained.min.z >= min.z &&
3996  contained.max.x <= max.x &&
3997  contained.max.y <= max.y &&
3998  contained.max.z <= max.z);
3999  }
4000 
4006  HPS_INLINE bool Contains(Point_3D<F> const & contained) const {
4007  return (contained.x >= min.x &&
4008  contained.y >= min.y &&
4009  contained.z >= min.z &&
4010  contained.x <= max.x &&
4011  contained.y <= max.y &&
4012  contained.z <= max.z);
4013  }
4014 
4021  HPS_INLINE bool Contains(Point_3D<F> const & contained, F epsilon) const {
4022  return (contained.x >= min.x - epsilon &&
4023  contained.y >= min.y - epsilon &&
4024  contained.z >= min.z - epsilon &&
4025  contained.x <= max.x + epsilon &&
4026  contained.y <= max.y + epsilon &&
4027  contained.z <= max.z + epsilon);
4028  }
4029 
4035  HPS_INLINE Cuboid_3D & Intersect(Cuboid_3D const & cuboid) {
4036  Float::replace_if_larger(min.x, cuboid.min.x);
4037  Float::replace_if_larger(min.y, cuboid.min.y);
4038  Float::replace_if_larger(min.z, cuboid.min.z);
4039  Float::replace_if_smaller(max.x, cuboid.max.x);
4040  Float::replace_if_smaller(max.y, cuboid.max.y);
4041  Float::replace_if_smaller(max.z, cuboid.max.z);
4042  return *this;
4043  }
4044 
4050  HPS_INLINE Cuboid_3D & Union(Cuboid_3D const & cuboid) {
4051  Float::replace_if_smaller(min.x, cuboid.min.x);
4052  Float::replace_if_smaller(min.y, cuboid.min.y);
4053  Float::replace_if_smaller(min.z, cuboid.min.z);
4054  Float::replace_if_larger(max.x, cuboid.max.x);
4055  Float::replace_if_larger(max.y, cuboid.max.y);
4056  Float::replace_if_larger(max.z, cuboid.max.z);
4057  return *this;
4058  }
4059 
4065  HPS_INLINE Cuboid_3D & Expand(F border) {
4066  Vector_3D<F> delta (border, border, border);
4067  min -= delta;
4068  max += delta;
4069  return *this;
4070  }
4071 
4077  HPS_INLINE Cuboid_3D & Contract(F border) {
4078  Vector_3D<F> delta (border, border, border);
4079  min += delta;
4080  max -= delta;
4081  return *this;
4082  }
4083 
4084 private:
4085  HPS_INLINE static Point_3D<F> Limit_Point () {
4086  F const limit = std::numeric_limits<F>::max();
4087  return Point_3D<F> (limit, limit, limit);
4088  }
4089 
4090  bool LineIntersecting (Point_3D<F> const & start, Vector_3D<F> const & direction, bool is_ray) const;
4091 };
4092 
4093 typedef Cuboid_3D<float> SimpleCuboid;
4094 typedef Cuboid_3D<double> DSimpleCuboid;
4095 
4096 
4097 template <typename F>
4098 HPS_INLINE Cuboid_3D<F> Intersect(Cuboid_3D<F> const & a, Cuboid_3D<F> const & b) {
4099  Cuboid_3D<F> temp = a;
4100  return temp.Intersect(b);
4101 }
4102 
4103 template <typename F>
4104 HPS_INLINE Cuboid_3D<F> Union(Cuboid_3D<F> const & a, Cuboid_3D<F> const & b) {
4105  Cuboid_3D<F> temp = a;
4106  return temp.Union(b);
4107 }
4108 
4109 template <typename F>
4110 HPS_INLINE Cuboid_3D<F> Expand(Cuboid_3D<F> const & a, F border) {
4111  Cuboid_3D<F> temp = a;
4112  return temp.Expand(border);
4113 }
4114 
4115 template <typename F>
4116 HPS_INLINE Cuboid_3D<F> Contract(Cuboid_3D<F> const & a, F border) {
4117  Cuboid_3D<F> temp = a;
4118  return temp.Contract(border);
4119 }
4120 
4121 
4122 
4123 template <typename F>
4124 struct HPS_TEMPLATE_API Sphere_3D {
4125  Point_3D<F> center;
4126  F radius;
4127 
4128  Sphere_3D () : center(Point_3D<F>(0, 0, 0)), radius(0) {}
4129 
4130  template <typename D>
4131  explicit Sphere_3D (Sphere_3D<D> const & that) : center(Point_3D<F>(that.center)), radius(F(that.radius)) {}
4132 
4133  Sphere_3D (Cuboid_3D<F> const & cuboid) :
4134  center (Midpoint(cuboid.min, cuboid.max)), radius (F(0.5 * cuboid.Diagonal().Length())) {}
4135 
4136  Sphere_3D (Point_3D<F> const & starting_center, F in_radius = 0) : center(starting_center), radius(in_radius) {}
4137 
4138  Sphere_3D (size_t count, Point_3D<F> const * points) : radius(0.0f) {
4139  Cuboid_3D<F> cuboid(count, points);
4140  center = Midpoint(cuboid.min, cuboid.max);
4141  Engulf (count, points);
4142  }
4143 
4144  Sphere_3D (size_t count, Point_3D<F> const * points, Point_3D<F> const & starting_center) : center(starting_center), radius(0) {
4145  Engulf (count, points);
4146  }
4147 
4148  HPS_INLINE bool IsValid() const {
4149  return radius >= 0;
4150  }
4151 
4152  static HPS_INLINE Sphere_3D Invalid() {return Sphere_3D(Point_3D<F>(0,0,0), -1);};
4153 
4154  void Invalidate() {radius = -1;}
4155 
4156  HPS_INLINE bool operator== (Sphere_3D const & sphere) const { return (center == sphere.center && radius == sphere.radius); }
4157  HPS_INLINE bool operator!= (Sphere_3D const & sphere) const { return !(*this == sphere); }
4158 
4159  HPS_INLINE F Volume () const { return F((4.0 / 3.0 * PI) * radius * radius * radius); }
4160 
4161  HPS_INLINE void Merge(Point_3D<F> const & point) {
4162  Vector_3D<F> dir = point - center;
4163  F distance = (F)dir.Length();
4164 
4165  if (distance > radius) {
4166  F t = F(0.5) * (distance - radius);
4167  center += t * dir.Normalize();
4168  radius += t;
4169  }
4170  }
4171 
4172  HPS_INLINE void Merge(size_t count, Point_3D<F> const * points) {
4173 
4174  for (size_t i = 0; i < count; ++i) {
4175  Vector_3D<F> dir = *points - center;
4176  F distance = (F)dir.Length();
4177 
4178  if (distance > radius) {
4179  F t = F(0.5) * (distance - radius);
4180  center += t * dir.Normalize();
4181  radius += t;
4182  }
4183 
4184  ++points;
4185  }
4186  }
4187 
4188  HPS_INLINE void Merge (Sphere_3D const & sphere) {
4189  Vector_3D<F> dir = sphere.center - center;
4190  F distance = (F)dir.Length();
4191 
4192  if (distance + sphere.radius > radius) {
4193  if (distance + radius > sphere.radius) {
4194  F t = F(0.5 * (sphere.radius + distance - radius));
4195  center += t * dir.Normalize();
4196  radius += t;
4197  }
4198  else {
4199  center = sphere.center;
4200  radius = sphere.radius;
4201  }
4202  }
4203  }
4204 
4205  HPS_INLINE void Merge (Cuboid_3D<F> const & cuboid) { Merge (Sphere_3D (cuboid)); }
4206 
4207 private:
4208  // Engulf expands the sphere to include the points, but does not change the center as Merge does
4209  HPS_INLINE void Engulf (size_t count, Point_3D<F> const * points) {
4210  for (size_t i = 0; i < count; ++i) {
4211  double dsq = (*points++ - center).LengthSquared();
4212  if ((F)dsq > radius * radius)
4213  radius = (F)sqrt(dsq);
4214  }
4215  }
4216 };
4217 
4218 typedef Sphere_3D<float> SimpleSphere;
4219 typedef Sphere_3D<double> DSimpleSphere;
4220 
4221 
4222 template <typename F>
4223 HPS_INLINE Cuboid_3D<F>::Cuboid_3D(Sphere_3D<F> const & sphere) {
4224  min = Point_3D<F>(sphere.center.x - sphere.radius, sphere.center.y - sphere.radius, sphere.center.z - sphere.radius);
4225  max = Point_3D<F>(sphere.center.x + sphere.radius, sphere.center.y + sphere.radius, sphere.center.z + sphere.radius);
4226 }
4227 
4228 
4229 
4230 
4231 class RGB24Color;
4232 class RGBA32Color;
4233 class RGBAS32Color;
4234 class RGBAColor;
4235 
4236 class HPS_API RGBColor {
4237 public:
4238  float red;
4239  float green;
4240  float blue;
4241 
4242  HPS_INLINE RGBColor () {}
4243  HPS_INLINE RGBColor (float r, float g, float b) : red (r), green (g), blue (b) {}
4244  explicit HPS_INLINE RGBColor (RGB24Color const & c24);
4245  explicit HPS_INLINE RGBColor (float gray) : red (gray), green (gray), blue (gray) {}
4246  explicit HPS_INLINE RGBColor (RGBAS32Color const & c32);
4247  explicit HPS_INLINE RGBColor (RGBA32Color const & c32);
4248  explicit HPS_INLINE RGBColor (RGBAColor const & c);
4249 
4250  HPS_INLINE bool IsGray() const {return (red == green && green == blue);}
4251  HPS_INLINE float Gray() const { return 0.3125f * red + 0.5000f * green + 0.1875f * blue; }
4252  float Distance(RGBColor const & other_color) const;
4253  HPS_INLINE bool IsValid() const {
4254  return (Float::extract_sign_bit(red) | Float::extract_sign_bit(green) | Float::extract_sign_bit(blue)) == 0;
4255  }
4256 
4257  HPS_INLINE bool operator== (RGBColor const & c) const { return red == c.red && green == c.green && blue == c.blue; }
4258  HPS_INLINE bool operator!= (RGBColor const & c) const { return !(*this == c); }
4259 
4260  HPS_INLINE bool Equals(RGBColor const & c, int in_tolerance = 32) const
4261  { return Float::Equals(red, c.red, in_tolerance) && Float::Equals(green, c.green, in_tolerance) && Float::Equals(blue, c.blue, in_tolerance); }
4262 
4263  HPS_INLINE RGBColor & operator*= (RGBColor const & c) { red *= c.red; green *= c.green; blue *= c.blue; return *this; }
4264  HPS_INLINE RGBColor & operator+= (RGBColor const & c) { red += c.red; green += c.green; blue += c.blue; return *this; }
4265  HPS_INLINE RGBColor & operator-= (RGBColor const & c) { red -= c.red; green -= c.green; blue -= c.blue; return *this; }
4266  HPS_INLINE RGBColor const operator* (RGBColor const & c) const { return RGBColor (red * c.red, green * c.green, blue * c.blue); }
4267  HPS_INLINE RGBColor const operator+ (RGBColor const & c) const { return RGBColor (red + c.red, green + c.green, blue + c.blue); }
4268  HPS_INLINE RGBColor const operator- (RGBColor const & c) const { return RGBColor (red - c.red, green - c.green, blue - c.blue); }
4269 
4270  HPS_INLINE RGBColor & operator*= (float s) { red *= s; green *= s; blue *= s; return *this; }
4271  HPS_INLINE RGBColor & operator/= (float s) { return operator*= (1.0f / s); }
4272  HPS_INLINE RGBColor & operator+= (float s) { red += s; green += s; blue += s; return *this; }
4273  HPS_INLINE RGBColor & operator-= (float s) { red -= s; green -= s; blue -= s; return *this; }
4274  HPS_INLINE RGBColor const operator* (float s) const { return RGBColor (red * s, green * s, blue * s); }
4275  HPS_INLINE RGBColor const operator/ (float s) const { return operator* (1.0f / s); }
4276  HPS_INLINE RGBColor const operator+ (float s) const { return RGBColor (red + s, green + s, blue + s); }
4277  HPS_INLINE RGBColor const operator- (float s) const { return RGBColor (red - s, green - s, blue - s); }
4278 
4279  static HPS_INLINE RGBColor Black() {return RGBColor (0, 0, 0);};
4280  static HPS_INLINE RGBColor White() {return RGBColor (1, 1, 1);};
4281  static HPS_INLINE RGBColor Invalid() {return RGBColor (-1, -1, -1);};
4282 
4283  void ShowHLS(float & out_hue, float & out_lightness, float & out_saturation) const;
4284  void ShowHSV(float & out_hue, float & out_saturation, float & out_value) const;
4285  void ShowHIC(float & out_hue, float & out_intensity, float & out_chromaticity) const;
4286 
4287  static RGBColor HLS(float in_hue, float in_lightness, float in_saturation);
4288  static RGBColor HSV(float in_hue, float in_saturation, float in_value);
4289  static RGBColor HIC(float in_hue, float in_intensity, float in_chromaticity);
4290 };
4291 
4292 HPS_INLINE RGBColor const operator* (float s, RGBColor const & v) { return RGBColor (s * v.red, s * v.green, s * v.blue); }
4293 HPS_INLINE RGBColor const operator+ (float s, RGBColor const & v) { return RGBColor (s + v.red, s + v.green, s + v.blue); }
4294 HPS_INLINE RGBColor const operator- (float s, RGBColor const & v) { return RGBColor (s - v.red, s - v.green, s - v.blue); }
4295 
4296 
4297 class HPS_API RGBAColor {
4298 public:
4299 
4300  float red;
4301  float green;
4302  float blue;
4303  float alpha;
4305  HPS_INLINE RGBAColor () {}
4306  explicit HPS_INLINE RGBAColor (float gray, float a = 1) : red (gray), green (gray), blue (gray), alpha (a) {}
4307  HPS_INLINE RGBAColor (float r, float g, float b, float a = 1) : red (r), green (g), blue (b), alpha (a) {}
4308 
4309  HPS_INLINE RGBAColor (RGBColor const & c) {
4310  memcpy(this, &c, sizeof(RGBColor)); //-V512
4311  alpha = 1.0f;
4312  Float::apply_sign_bit(alpha, Float::extract_sign_bit(c.red) | Float::extract_sign_bit(c.green) | Float::extract_sign_bit(c.blue));
4313  }
4314  HPS_INLINE RGBAColor (RGBColor const & c, float a) {
4315  memcpy(this, &c, sizeof(RGBColor));
4316  memcpy(&alpha, &a, sizeof(float));
4317  Float::apply_sign_bit(alpha, Float::extract_sign_bit(c.red) | Float::extract_sign_bit(c.green) | Float::extract_sign_bit(c.blue));
4318  }
4319  explicit HPS_INLINE RGBAColor (RGBA32Color const & c32);
4320  explicit HPS_INLINE RGBAColor (RGBAS32Color const & c32);
4321 
4322  HPS_INLINE bool IsGray() const {return (red == green && green == blue);}
4323  HPS_INLINE float Gray() const { return 0.3125f * red + 0.5000f * green + 0.1875f * blue; }
4324  HPS_INLINE bool IsValid() const {
4325  return (Float::extract_sign_bit(red) | Float::extract_sign_bit(green) | Float::extract_sign_bit(blue) | Float::extract_sign_bit(alpha)) == 0;
4326  }
4327 
4334  HPS_INLINE bool operator== (RGBAColor const & c) const { return red == c.red && green == c.green && blue == c.blue && alpha == c.alpha; }
4335 
4342  HPS_INLINE bool operator!= (RGBAColor const & c) const { return !(*this == c); }
4343 
4344  HPS_INLINE bool Equals(RGBAColor const & c, int in_tolerance = 32) const {
4345  return Float::Equals(red, c.red, in_tolerance) && Float::Equals(green, c.green, in_tolerance) &&
4346  Float::Equals(blue, c.blue, in_tolerance) && Float::Equals(alpha, c.alpha, in_tolerance);
4347  }
4348 
4349  HPS_INLINE RGBAColor & operator*= (RGBAColor const & c) { red *= c.red; green *= c.green; blue *= c.blue; alpha *= c.alpha; return *this; }
4350  HPS_INLINE RGBAColor & operator+= (RGBAColor const & c) { red += c.red; green += c.green; blue += c.blue; alpha += c.alpha; return *this; }
4351  HPS_INLINE RGBAColor & operator-= (RGBAColor const & c) { red -= c.red; green -= c.green; blue -= c.blue; alpha -= c.alpha; return *this; }
4352  HPS_INLINE RGBAColor const operator* (RGBAColor const & c) const { return RGBAColor (red * c.red, green * c.green, blue * c.blue, alpha * c.alpha); }
4353  HPS_INLINE RGBAColor const operator+ (RGBAColor const & c) const { return RGBAColor (red + c.red, green + c.green, blue + c.blue, alpha + c.alpha); }
4354  HPS_INLINE RGBAColor const operator- (RGBAColor const & c) const { return RGBAColor (red - c.red, green - c.green, blue - c.blue, alpha - c.alpha); }
4355 
4356  HPS_INLINE RGBAColor & operator*= (float s) { red *= s; green *= s; blue *= s; alpha *= s; return *this; }
4357  HPS_INLINE RGBAColor & operator/= (float s) { return operator*= (1.0f / s); }
4358  HPS_INLINE RGBAColor & operator+= (float s) { red += s; green += s; blue += s; alpha += s; return *this; }
4359  HPS_INLINE RGBAColor & operator-= (float s) { red -= s; green -= s; blue -= s; alpha -= s; return *this; }
4360  HPS_INLINE RGBAColor const operator* (float s) const { return RGBAColor (red * s, green * s, blue * s, alpha * s); }
4361  HPS_INLINE RGBAColor const operator/ (float s) const { return operator* (1.0f / s); }
4362  HPS_INLINE RGBAColor const operator+ (float s) const { return RGBAColor (red + s, green + s, blue + s, alpha + s); }
4363  HPS_INLINE RGBAColor const operator- (float s) const { return RGBAColor (red - s, green - s, blue - s, alpha - s); }
4364 
4365  HPS_INLINE RGBAColor & operator*= (RGBColor const & c) { red *= c.red; green *= c.green; blue *= c.blue; return *this; }
4366  HPS_INLINE RGBAColor & operator+= (RGBColor const & c) { red += c.red; green += c.green; blue += c.blue; return *this; }
4367  HPS_INLINE RGBAColor & operator-= (RGBColor const & c) { red -= c.red; green -= c.green; blue -= c.blue; return *this; }
4368  HPS_INLINE RGBAColor const operator* (RGBColor const & c) const { return RGBAColor (red * c.red, green * c.green, blue * c.blue, alpha); }
4369  HPS_INLINE RGBAColor const operator+ (RGBColor const & c) const { return RGBAColor (red + c.red, green + c.green, blue + c.blue, alpha); }
4370  HPS_INLINE RGBAColor const operator- (RGBColor const & c) const { return RGBAColor (red - c.red, green - c.green, blue - c.blue, alpha); }
4371 
4372  static HPS_INLINE RGBAColor Black() {return RGBAColor (0, 0, 0, 1);};
4373  static HPS_INLINE RGBAColor White() {return RGBAColor (1, 1, 1, 1);};
4374  static HPS_INLINE RGBAColor Nothing() {return RGBAColor (0, 0, 0, 0);};
4375  static HPS_INLINE RGBAColor Invalid() {return RGBAColor (-1, -1, -1, -1);};
4376 };
4377 
4378 
4379 
4381 public:
4382  enum Order {
4383  Order_ABGR,
4384  Order_RGBA,
4385  Order_BGRA
4386  };
4387 
4388 #ifdef _MSC_VER
4389  HPS_INLINE static Order Preferred_Order () {return Order_BGRA;}
4390  unsigned char b, g, r, a;
4391 #endif
4392 
4393 #ifdef __linux__
4394  HPS_INLINE static Order Preferred_Order () {return Order_RGBA;}
4395  unsigned char r, g, b, a;
4396 #endif
4397 
4398 #ifdef __APPLE_CC__
4399  HPS_INLINE static Order Preferred_Order () {return Order_RGBA;}
4400  unsigned char r, g, b, a;
4401 #endif
4402 };
4403 
4404 
4405 
4407 public:
4408 
4409  HPS_INLINE RGBAS32Color () /* : DirectRGBColor() */ {}
4410  explicit HPS_INLINE RGBAS32Color (unsigned char gray, unsigned char aa = 255) {
4411  r = gray;
4412  g = gray;
4413  b = gray;
4414  a = aa;
4415  }
4416  HPS_INLINE RGBAS32Color (unsigned char rr, unsigned char gg, unsigned char bb, unsigned char aa = 255) {
4417  r = rr;
4418  g = gg;
4419  b = bb;
4420  a = aa;
4421  }
4422  HPS_INLINE RGBAS32Color (DirectRGBColor const & c) : DirectRGBColor(c) {};
4423 
4424  explicit HPS_INLINE RGBAS32Color (RGBColor const & c)
4425  {
4426  r = Float::unit_to_byte(c.red);
4427  g = Float::unit_to_byte(c.green);
4428  b = Float::unit_to_byte(c.blue);
4429  a = 255;
4430  }
4431 
4432  HPS_INLINE RGBAS32Color (RGB24Color const & c);
4433 
4434  HPS_INLINE RGBAS32Color (RGBA32Color const & c);
4435 
4436  HPS_INLINE RGBAS32Color (RGBColor const & c, float alpha)
4437  {
4438  r = Float::unit_to_byte(c.red);
4439  g = Float::unit_to_byte(c.green);
4440  b = Float::unit_to_byte(c.blue);
4441  a = Float::unit_to_byte(alpha);
4442  }
4443  HPS_INLINE RGBAS32Color (RGBColor const & c, unsigned char aa)
4444  {
4445  r = Float::unit_to_byte(c.red);
4446  g = Float::unit_to_byte(c.green);
4447  b = Float::unit_to_byte(c.blue);
4448  a = aa;
4449  }
4450  explicit HPS_INLINE RGBAS32Color (RGBAColor const & c)
4451  {
4452  r = Float::unit_to_byte(c.red);
4453  g = Float::unit_to_byte(c.green);
4454  b = Float::unit_to_byte(c.blue);
4455  a = Float::unit_to_byte(c.alpha);
4456  }
4457  HPS_INLINE RGBAS32Color (RGBAColor const & c, unsigned char mix)
4458  {
4459  r = Float::unit_to_byte(c.red);
4460  g = Float::unit_to_byte(c.green);
4461  b = Float::unit_to_byte(c.blue);
4462  a = Float::unit_to_byte_scaled(c.alpha, mix);
4463  }
4464 
4465  HPS_INLINE bool IsGray() const {return (r == g && g == b);}
4466  HPS_INLINE unsigned char Gray() const { return (unsigned char)(0.3125f * (float)r + 0.5000f * (float)g + 0.1875f * (float)b); }
4467  HPS_INLINE bool IsValid() const { return ((r | g | b | a) != 0); }
4468 
4469  HPS_INLINE bool operator== (RGBAS32Color const & c) const { return (r == c.r && g == c.g && b == c.b && a == c.a); }
4470  HPS_INLINE bool operator!= (RGBAS32Color const & c) const { return !(*this == c); }
4471 
4472  static HPS_INLINE RGBAS32Color Black() {return RGBAS32Color (0, 0, 0, 255);};
4473  static HPS_INLINE RGBAS32Color White() {return RGBAS32Color (255, 255, 255, 255);};
4474  static HPS_INLINE RGBAS32Color Invalid() {return RGBAS32Color (0, 0, 0, 0);};
4475 
4476  static HPS_INLINE unsigned char Opaque_Alpha () {return 0xFF;}
4477 };
4478 
4480 public:
4481  unsigned char r;
4482  unsigned char g;
4483  unsigned char b;
4484  unsigned char a;
4485 
4486  HPS_INLINE RGBA32Color () {}
4487  explicit HPS_INLINE RGBA32Color (unsigned char gray, unsigned char aa = 255)
4488  : r (gray), g (gray), b (gray), a (aa) {}
4489  HPS_INLINE RGBA32Color (unsigned char rr, unsigned char gg, unsigned char bb, unsigned char aa = 255)
4490  : r (rr), g (gg), b (bb), a (aa) {}
4491  HPS_INLINE RGBA32Color (RGBAS32Color const & c32)
4492  : r (c32.r), g (c32.g), b (c32.b), a (c32.a) {}
4493  explicit HPS_INLINE RGBA32Color (RGBColor const & c) {
4494  r = Float::unit_to_byte(c.red);
4495  g = Float::unit_to_byte(c.green);
4496  b = Float::unit_to_byte(c.blue);
4497  a = 255;
4498  }
4499  HPS_INLINE RGBA32Color (RGBColor const & c, float alpha) {
4500  r = Float::unit_to_byte(c.red);
4501  g = Float::unit_to_byte(c.green);
4502  b = Float::unit_to_byte(c.blue);
4503  a = Float::unit_to_byte(alpha);
4504  }
4505  HPS_INLINE RGBA32Color (RGBColor const & c, unsigned char aa) {
4506  r = Float::unit_to_byte(c.red);
4507  g = Float::unit_to_byte(c.green);
4508  b = Float::unit_to_byte(c.blue);
4509  a = aa;
4510  }
4511  explicit HPS_INLINE RGBA32Color (RGBAColor const & c) {
4512  r = Float::unit_to_byte(c.red);
4513  g = Float::unit_to_byte(c.green);
4514  b = Float::unit_to_byte(c.blue);
4515  a = Float::unit_to_byte(c.alpha);
4516  }
4517  HPS_INLINE RGBA32Color (RGBAColor const & c, unsigned char mix) {
4518  r = Float::unit_to_byte(c.red);
4519  g = Float::unit_to_byte(c.green);
4520  b = Float::unit_to_byte(c.blue);
4521  a = Float::unit_to_byte_scaled(c.alpha, mix);
4522  }
4523 
4524  HPS_INLINE bool IsGray() const {return (r == g && g == b);}
4525  HPS_INLINE unsigned char Gray() const { return (unsigned char)(0.3125f * (float)r + 0.5000f * (float)g + 0.1875f * (float)b); }
4526 
4527  HPS_INLINE bool operator== (RGBA32Color const & c) const { return (r == c.r && g == c.g && b == c.b && a == c.a); }
4528  HPS_INLINE bool operator!= (RGBA32Color const & c) const { return !(*this == c); }
4529 
4530  static HPS_INLINE RGBA32Color Black() {return RGBA32Color (0, 0, 0, 255);};
4531  static HPS_INLINE RGBA32Color White() {return RGBA32Color (255, 255, 255, 255);};
4532 
4533  static HPS_INLINE unsigned char Opaque_Alpha () {return 0xFF;}
4534 };
4535 
4536 
4538 {
4539 public:
4540  unsigned char r;
4541  unsigned char g;
4542  unsigned char b;
4543 
4544  HPS_INLINE RGB24Color () {}
4545  explicit HPS_INLINE RGB24Color (unsigned char gray)
4546  : r (gray), g (gray), b (gray) {}
4547  HPS_INLINE RGB24Color (unsigned char rr, unsigned char gg, unsigned char bb)
4548  : r (rr), g (gg), b (bb) {}
4549  explicit HPS_INLINE RGB24Color (RGBColor const & c) {
4550  r = Float::unit_to_byte(c.red);
4551  g = Float::unit_to_byte(c.green);
4552  b = Float::unit_to_byte(c.blue);
4553  }
4554 
4555  HPS_INLINE bool IsGray() const {return (r == g && g == b);}
4556  HPS_INLINE unsigned char Gray() const { return (unsigned char)(0.3125f * (float)r + 0.5000f * (float)g + 0.1875f * (float)b); }
4557 
4558  HPS_INLINE bool operator== (RGB24Color const & c) const { return (r == c.r && g == c.g && b == c.b); }
4559  HPS_INLINE bool operator!= (RGB24Color const & c) const { return !(*this == c); }
4560 };
4561 
4562 HPS_INLINE RGBColor::RGBColor (RGBAS32Color const & c32) {
4563  red = Float::C2F(c32.r);
4564  green = Float::C2F(c32.g);
4565  blue = Float::C2F(c32.b);
4566 }
4567 
4568 HPS_INLINE RGBColor::RGBColor (RGBA32Color const & c32) {
4569  red = Float::C2F(c32.r);
4570  green = Float::C2F(c32.g);
4571  blue = Float::C2F(c32.b);
4572 }
4573 
4574 HPS_INLINE RGBColor::RGBColor (RGBAColor const & c) {
4575  red = c.red;
4576  green = c.green;
4577  blue = c.blue;
4578 }
4579 
4580 HPS_INLINE RGBColor::RGBColor (RGB24Color const & c24) {
4581  red = Float::C2F(c24.r);
4582  green = Float::C2F(c24.g);
4583  blue = Float::C2F(c24.b);
4584 }
4585 
4586 HPS_INLINE RGBAS32Color::RGBAS32Color (RGB24Color const & c)
4587 {
4588  r = c.r;
4589  g = c.g;
4590  b = c.b;
4591  a = 255;
4592 }
4593 
4594 HPS_INLINE RGBAS32Color::RGBAS32Color (RGBA32Color const & c)
4595 {
4596  r = c.r;
4597  g = c.g;
4598  b = c.b;
4599  a = c.a;
4600 }
4601 
4602 HPS_INLINE RGBAColor::RGBAColor (RGBAS32Color const & c32) {
4603  red = Float::C2F(c32.r);
4604  green = Float::C2F(c32.g);
4605  blue = Float::C2F(c32.b);
4606  alpha = Float::C2F(c32.a);
4607 }
4608 
4609 HPS_INLINE RGBAColor::RGBAColor (RGBA32Color const & c32) {
4610  red = Float::C2F(c32.r);
4611  green = Float::C2F(c32.g);
4612  blue = Float::C2F(c32.b);
4613  alpha = Float::C2F(c32.a);
4614 }
4615 
4616 HPS_INLINE RGBColor Modulate(RGBColor const & a, RGBColor const & b) {
4617  return RGBColor(a.red * b.red, a.green * b.green, a.blue * b.blue);
4618 }
4619 
4620 
4621 
4622 HPS_INLINE RGBColor Interpolate(RGBColor const & a, RGBColor const & b, float t) {
4623  return RGBColor(a.red + (b.red - a.red) * t, a.green + (b.green - a.green) * t, a.blue + (b.blue - a.blue) * t);
4624 }
4625 
4626 HPS_INLINE RGBAColor Interpolate(RGBAColor const & a, RGBAColor const & b, float t) {
4627  return RGBAColor(a.red + (b.red - a.red) * t, a.green + (b.green - a.green) * t, a.blue + (b.blue - a.blue) * t, a.alpha + (b.alpha - a.alpha) * t);
4628 }
4629 
4630 HPS_INLINE RGBAS32Color Interpolate(RGBAS32Color const & a, RGBAS32Color const & b, float t) {
4631  return RGBAS32Color(
4632  (unsigned char)(a.r + ((float)b.r - (float)a.r) * t),
4633  (unsigned char)(a.g + ((float)b.g - (float)a.g) * t),
4634  (unsigned char)(a.b + ((float)b.b - (float)a.b) * t),
4635  (unsigned char)(a.a + ((float)b.a - (float)a.a) * t));
4636 }
4637 
4638 HPS_INLINE RGBA32Color Interpolate(RGBA32Color const & a, RGBA32Color const & b, float t) {
4639  return RGBA32Color(
4640  (unsigned char)(a.r + ((float)b.r - (float)a.r) * t),
4641  (unsigned char)(a.g + ((float)b.g - (float)a.g) * t),
4642  (unsigned char)(a.b + ((float)b.b - (float)a.b) * t),
4643  (unsigned char)(a.a + ((float)b.a - (float)a.a) * t));
4644 }
4645 
4646 HPS_INLINE RGB24Color Interpolate(RGB24Color const & a, RGB24Color const & b, float t) {
4647  return RGB24Color(
4648  (unsigned char)(a.r + ((float)b.r - (float)a.r) * t),
4649  (unsigned char)(a.g + ((float)b.g - (float)a.g) * t),
4650  (unsigned char)(a.b + ((float)b.b - (float)a.b) * t));
4651 }
4652 
4653 
4654 
4655 class HPS_API Quaternion {
4656 public:
4657  float w;
4658  float x;
4659  float y;
4660  float z;
4661 
4662  Quaternion() : w(0.0f), x(0.0f), y(0.0f), z(0.0f) { }
4663 
4664  Quaternion(float in_w, float in_x, float in_y, float in_z) : w(in_w), x(in_x), y(in_y), z(in_z) { }
4665 
4666  Quaternion(Quaternion const & that) : w(that.w), x(that.x), y(that.y), z(that.z) { }
4667 
4668  Quaternion const & Normalize() {
4669  float mag = Norm();
4670 
4671  if (mag > 0) {
4672  w /= mag;
4673  x /= mag;
4674  y /= mag;
4675  z /= mag;
4676  }
4677  return *this;
4678  }
4679 
4680 
4681  Quaternion operator* (Quaternion const & in_right) const {
4682  return Quaternion(w*in_right.w - x*in_right.x - y*in_right.y - z*in_right.z,
4683  y*in_right.z - z*in_right.y + w*in_right.x + x*in_right.w,
4684  z*in_right.x - x*in_right.z + w*in_right.y + y*in_right.w,
4685  x*in_right.y - y*in_right.x + w*in_right.z + z*in_right.w);
4686  }
4687 
4688  Quaternion operator* (float in_right) const {
4689  return Quaternion(w*in_right, x*in_right, y*in_right, z*in_right);
4690  }
4691 
4692  friend Quaternion operator* (float in_left, Quaternion const & in_right) {
4693  return Quaternion(in_left*in_right.w, in_left*in_right.x, in_left*in_right.y, in_left*in_right.z);
4694  }
4695 
4696  Quaternion operator/ (float in_right) const {
4697  return Quaternion(w/in_right, x/in_right, y/in_right, z/in_right);
4698  }
4699 
4700  Quaternion operator- (Quaternion const & in_right) const {
4701  return Quaternion(w-in_right.w, x-in_right.x, y-in_right.y, z-in_right.z);
4702  }
4703 
4704  Quaternion operator+ (Quaternion const & in_right) const {
4705  return Quaternion(w+in_right.w, x+in_right.x, y+in_right.y, z+in_right.z);
4706  }
4707 
4708  inline float Norm() const {
4709  return static_cast<float>(sqrt(w*w + x*x + y*y + z*z));
4710  }
4711 
4712 
4713  Quaternion Log() const {
4714  Quaternion ret;
4715  float mag_q = Norm();
4716  float mag_V = static_cast<float>(sqrt(x*x + y*y + z*z));
4717 
4718  ret.w = static_cast<float>(log(mag_q));
4719 
4720  if (mag_V > 0) {
4721  float scale = static_cast<float>(acos(w / mag_q) / mag_V);
4722 
4723  ret.x = x * scale;
4724  ret.y = y * scale;
4725  ret.z = z * scale;
4726  }
4727  else
4728  ret.x = ret.y = ret.z = 0;
4729 
4730  return ret;
4731  }
4732 
4733  Quaternion Exp() const {
4734  Quaternion ret;
4735  float ea = static_cast<float>(exp(w));
4736  float mag_V = static_cast<float>(sqrt(x*x + y*y + z*z));
4737  float scale = ea * sin(mag_V) / mag_V;
4738 
4739  ret.w = ea * cos(mag_V);
4740  ret.x = scale * x;
4741  ret.y = scale * y;
4742  ret.z = scale * z;
4743 
4744  return ret;
4745  }
4746 
4747  Quaternion Lerp(Quaternion const & in_right, float in_fraction) const {
4748  Quaternion ret = *this + in_fraction * (in_right - *this);
4749  return ret.Normalize();
4750  }
4751 
4752 
4753  Quaternion Slerp(Quaternion const & in_right, float in_fraction, bool in_shortest_path_only = true) const {
4754  Quaternion q3;
4755  float dot = x*in_right.x + y*in_right.y + z*in_right.z + w*in_right.w;
4756 
4757  if (in_shortest_path_only && dot < 0) {
4758  dot = -dot;
4759  q3 = -1 * in_right;
4760  }
4761  else
4762  q3 = in_right;
4763 
4764  if (dot > -0.95f && dot < 0.95f) {
4765  float angle = static_cast<float>(acos(dot));
4766  float sina = static_cast<float>(sin(angle));
4767  float sinat = static_cast<float>(sin(angle*in_fraction));
4768  float sinaomt = static_cast<float>(sin(angle*(1-in_fraction)));
4769 
4770  return (*this * sinaomt + q3 * sinat) / sina;
4771  }
4772  else //if the angle is small, we use linear interpolation
4773  return Lerp(q3, in_fraction);
4774  }
4775 
4776 
4777  /*
4778  Spherical cubic interpolation between two Quaternions
4779  \param in_right The Quaternion for interpolation.
4780  \param in_control1 The first control point.
4781  \param in_control2 The second control point.
4782  \param in_fraction Interpolation distance (0 - 1).
4783  \return Result of interpolation.
4784  */
4785  Quaternion Squad(Quaternion const & in_right, Quaternion const & in_control1, Quaternion const & in_control2, float in_fraction) const {
4786  Quaternion q1 = Slerp(in_right , in_fraction, false);
4787  Quaternion q2 = in_control1.Slerp(in_control2, in_fraction, false);
4788 
4789  return q1.Slerp(q2, 2*in_fraction*(1-in_fraction), false);
4790  }
4791 
4798  Quaternion Spline(Quaternion const & in_previous, Quaternion const & in_next) const {
4799  Quaternion qni(w, -x, -y, -z);
4800 
4801  return *this * Quaternion(((qni*in_previous).Log() + (qni*in_next).Log()) / -4).Exp();
4802  }
4803 
4804 };
4805 
4807 {
4808  size_t dot_dc_count;
4809  size_t dot_3d_count;
4810  size_t line_dc_count;
4811  size_t line_3d_count;
4824  size_t raster_count;
4825  size_t segment_count;
4830 };
4831 
4832 typedef unsigned char byte;
4833 typedef signed char sbyte;
4834 typedef intptr_t WindowHandle;
4835 typedef int64_t TouchID;
4836 typedef intptr_t PlatformData;
4837 typedef intptr_t OpaqueHandle;
4838 
4839 /*
4840 HPS Lexicon:
4841 
4842 Concept Class -- A class that contains only enums and possibly static functions. The
4843  constructor is usually private because they are not intended to be instantiated.
4844 
4845 Database -- (1) The internal space that stores and manages all HOOPS objects. Access to
4846  database objects is subject to locking to prevent threading deadlocks. (2) The class
4847  of the same name, offering static functions to initiate operations that take place
4848  within the database.
4849 
4850 Key -- A reference counted smart pointer to an object in the database. The
4851 
4852 Kit -- A user space object that carries a complete specification for a geometry, attribute,
4853  option group, or other type. Modifying a kit has no effect on the database unless
4854  and until it is applied. Kits should generally be passed by reference because they
4855  are potentially very large and copying them can be arduous.
4856 
4857 Smart Pointer -- An encapsulated, reference counted pointer to an internal object. Smart
4858  pointers should generally be passed by value to ensure the reference count is
4859  correct.
4860 
4861 User Space -- The external space occupied by all user code. User space objects are not
4862  in the database and are not subject to locking.
4863 
4864 */
4865 
4869 class SegmentKey;
4870 class AttributesControl;
4871 class LineKit;
4872 class LineKey;
4873 class TextKey;
4874 class TextKit;
4875 class Key;
4876 class VisibilityControl;
4877 class CameraControl;
4878 class SelectabilityControl;
4879 class TransparencyKit;
4880 class TransparencyControl;
4881 class CullingKit;
4882 class CullingControl;
4883 class GlyphKit;
4885 class GlyphDefinition;
4886 class GeometryInsertControl;
4887 class GlyphElement;
4888 class TextAttributeControl;
4889 class TextAttributeKit;
4890 class LineAttributeKit;
4891 class LineAttributeControl;
4892 class EdgeAttributeKit;
4893 class EdgeAttributeControl;
4894 class CurveAttributeKit;
4895 class CurveAttributeControl;
4896 class GlyphPoint;
4897 class MatrixKit;
4899 class TextureMatrixControl;
4900 class TextureDefinition;
4901 class MaterialMappingKit;
4903 class MaterialKit;
4904 class MarkerKit;
4905 class MarkerKey;
4906 class DistantLightKit;
4907 class DistantLightKey;
4908 class CuttingSectionKit;
4909 class CuttingSectionKey;
4912 class CylinderAttributeKit;
4914 class Cylinder;
4915 class CylinderKey;
4916 class CylinderKit;
4917 class SphereKey;
4918 class SphereKit;
4919 class SphereAttributeKit;
4921 class PolygonKit;
4922 class PolygonKey;
4923 class CircleKey;
4924 class CircleKit;
4925 class CircularArcKey;
4926 class CircularArcKit;
4927 class CircularWedgeKey;
4928 class CircularWedgeKit;
4929 class IncludeKey;
4930 class InfiniteLineKey;
4931 class InfiniteLineKit;
4932 class SpotlightKey;
4933 class SpotlightKit;
4934 class NURBSCurveKey;
4935 class NURBSCurveKit;
4936 class NURBSSurfaceKey;
4937 class NURBSSurfaceKit;
4938 class TrimKit;
4939 class TrimElement;
4940 class EllipseKey;
4941 class EllipseKit;
4942 class EllipticalArcKey;
4943 class EllipticalArcKit;
4944 class ShellKit;
4945 class ShellKey;
4946 class Shell;
4947 class MeshKit;
4948 class MeshKey;
4949 class WindowKey;
4950 class Database;
4953 class Driver;
4954 class Search;
4955 class PerformanceKit;
4956 class PerformanceControl;
4959 class DrawingAttributeKit;
4961 class PortfolioKey;
4962 class Selection;
4963 class SelectionOptionsKit;
4964 class SelectionResults;
4965 class SelectionItem;
4966 class SelectionControl;
4967 class HighlightControl;
4968 class HighlightOptionsKit;
4969 class ImageDefinition;
4970 class ImageKit;
4971 class TextureDefinition;
4972 class TextureOptionsKit;
4973 class NamedStyleDefinition;
4975 class GlyphDefinition;
4976 class LinePatternOptionsKit;
4977 class LinePatternDefinition;
4978 class LinePatternKit;
4979 class LinePatternElement;
4981 class CubeMapDefinition;
4982 class ShaderKit;
4983 class ShaderDefinition;
4984 class EmergencyHandler;
4985 class EventDispatcher;
4986 class EventHandler;
4987 class Event;
4988 class StandAloneWindowKey;
4990 class ApplicationWindowKey;
4992 class OffScreenWindowKey;
4995 class VisualEffectsControl;
4998 class ObjectPoint;
4999 class WorldPoint;
5000 class CameraPoint;
5001 class NormalizedPoint;
5002 class ScreenRangePoint;
5003 class InnerWindowPoint;
5004 class InnerPixelPoint;
5005 class WindowPoint;
5006 class PixelPoint;
5007 class VisibilityKit;
5008 class CameraKit;
5009 class SelectabilityKit;
5010 class MarkerAttributeKit;
5011 class LightingAttributeKit;
5012 class VisualEffectsKit;
5013 class PostProcessEffectsKit;
5014 class Portfolio;
5015 class SubwindowControl;
5016 class SubwindowKit;
5017 class World;
5018 class DebuggingControl;
5019 class DebuggingKit;
5020 class KeyPath;
5021 class ContourLineKit;
5022 class ContourLineControl;
5023 class UTF8;
5024 class StyleControl;
5025 class PortfolioControl;
5026 class Condition;
5027 class ConditionControl;
5028 class WindowInfoKit;
5029 class WindowInfoControl;
5030 class FontInfoState;
5031 class FontInfoControl;
5032 class SearchOptionsKit;
5033 class AttributeLockControl;
5034 class AttributeLockKit;
5035 class ReferenceKey;
5036 class StyleKey;
5037 class BoundingKit;
5038 class BoundingControl;
5039 class TransformMaskKit;
5040 class TransformMaskControl;
5041 class ColorInterpolationKit;
5043 class UpdateOptionsKit;
5044 class UpdateOptionsControl;
5045 class GeometryKey;
5046 class TreeContext;
5049 class GridKit;
5050 class GridKey;
5053 
5057 
5058 
5061 class HPS_API GlyphPoint
5062 {
5063 public:
5064 
5066  GlyphPoint();
5067 
5072  GlyphPoint(sbyte in_x, sbyte in_y);
5073 
5078  bool Equals(GlyphPoint const & in_that) const { return (x==in_that.x && y==in_that.y); }
5079 
5084  bool operator==(GlyphPoint const & in_that) const { return Equals(in_that); }
5085 
5090  bool operator!=(GlyphPoint const & in_that) const { return !Equals(in_that); }
5091 
5092  sbyte x;
5093  sbyte y;
5094 };
5095 
5098 enum class Type : uint32_t
5099 {
5100  None = 0x00000000,
5101  GenericMask = 0xffffff00,
5102 
5103  World = 0x00000001,
5104  UTF8 = 0x00000002,
5105  EventDispatcher = 0x00000003,
5106  EventHandler = 0x00000004,
5107  EventNotifier = 0x00000005,
5108  UpdateNotifier = 0x00000006,
5109  SearchResults = 0x00000008,
5110  FontSearchResults = 0x00000009,
5111  SearchResultsIterator = 0x0100000a, // Using Kit bit. Change to special Iterator bit?
5112  FontSearchResultsIterator = 0x0100000b, // Using Kit bit. Change to special Iterator bit?
5113  SelectionResults = 0x0000000c,
5114  SelectionResultsIterator = 0x0100000d, // Using Kit bit. Change to special Iterator bit?
5115  SelectionItem = 0x0000000e,
5116  TreeContext = 0x0000000f,
5117  StreamToolkit = 0x00000010,
5118  DriverEventHandler = 0x00000011,
5119 
5120  IONotifier = 0x04000100,
5121  StreamImportNotifier = 0x04000101,
5122  STLImportNotifier = 0x04000102,
5123  OBJImportNotifier = 0x04000103,
5124  ExchangeImportNotifier = 0x04000104,
5125  SketchupImportNotifier = 0x04000105,
5126  ParasolidImportNotifier = 0x04000106,
5127  ExchangeTranslationNotifier = 0x04000107,
5128  ExchangeExportNotifier = 0x04000108,
5129  StreamExportNotifier = 0x04000109,
5130  ExchangeReloadNotifier = 0x0400010a,
5131  DWGImportNotifier = 0x0400010b,
5132 
5133  Kit = 0x01000000,
5134  MarkerKit = 0x01000010,
5135  SphereAttributeKit = 0x01000011,
5136  TextAttributeKit = 0x01000012,
5137  TransparencyKit = 0x01000013,
5138  VisibilityKit = 0x01000014,
5139  VisualEffectsKit = 0x01000015,
5140  CuttingSectionAttributeKit = 0x01000016,
5141  CircleKit = 0x01000017,
5142  CircularArcKit = 0x01000018,
5143  CircularWedgeKit = 0x01000019,
5144  CuttingSectionKit = 0x0100001a,
5145  CylinderKit = 0x0100001b,
5146  DistantLightKit = 0x0100001c,
5147  EllipseKit = 0x0100001d,
5148  EllipticalArcKit = 0x0100001e,
5149  InfiniteLineKit = 0x0100001f,
5150  LineKit = 0x01000020,
5151  NURBSCurveKit = 0x01000021,
5152  MeshKit = 0x01000022,
5153  NURBSSurfaceKit = 0x01000023,
5154  PolygonKit = 0x01000024,
5155  SphereKit = 0x01000025,
5156  SpotlightKit = 0x01000026,
5157  ShellKit = 0x01000027,
5158  TextKit = 0x01000028,
5159  MaterialKit = 0x01000029,
5160  TrimKit = 0x0100002a,
5161  TextureOptionsKit = 0x0100002c,
5162  LinePatternKit = 0x0100002d,
5163  GlyphKit = 0x0100002e,
5164  ImageKit = 0x0100002f,
5165  LinePatternOptionsKit = 0x01000030,
5166  CameraKit = 0x01000031,
5167  BoundingKit = 0x01000032,
5168  CullingKit = 0x01000033,
5169  CurveAttributeKit = 0x01000034,
5170  CylinderAttributeKit = 0x01000035,
5171  EdgeAttributeKit = 0x01000036,
5172  LightingAttributeKit = 0x01000037,
5173  LineAttributeKit = 0x01000038,
5174  MarkerAttributeKit = 0x01000039,
5175  MaterialMappingKit = 0x0100003a,
5176  MatrixKit = 0x0100003b,
5177  NURBSSurfaceAttributeKit = 0x0100003c,
5178  PostProcessEffectsKit = 0x0100003d,
5179  SelectabilityKit = 0x0100003e,
5180  SelectionOptionsKit = 0x0100003f,
5181  StandAloneWindowOptionsKit = 0x01000040,
5182  OffScreenWindowOptionsKit = 0x01000041,
5183  ApplicationWindowOptionsKit = 0x01000042,
5184  HighlightOptionsKit = 0x01000043,
5185  LinePatternParallelKit = 0x01000044,
5186  SubwindowKit = 0x01000045,
5187  PerformanceKit = 0x01000046,
5188  HiddenLineAttributeKit = 0x01000047,
5189  DrawingAttributeKit = 0x01000048,
5190  ShaderKit = 0x01000049,
5191  DebuggingKit = 0x0100004a,
5192  ContourLineKit = 0x0100004b,
5193  StreamImportOptionsKit = 0x0100004c,
5194  StreamImportResultsKit = 0x0100004d,
5195  StreamExportOptionsKit = 0x0100004e,
5196  StreamExportResultsKit = 0x0100004f,
5197  WindowInfoKit = 0x01000050,
5198  ImageImportOptionsKit = 0x01000051,
5199  SearchOptionsKit = 0x01000052,
5200  ShaderImportOptionsKit = 0x01000053,
5201  HardcopyExportOptionsKit = 0x01000055,
5202  AttributeLockKit = 0x01000056,
5203  TransformMaskKit = 0x01000057,
5204  ColorInterpolationKit = 0x01000058,
5205  UpdateOptionsKit = 0x01000059,
5206  ImageExportOptionsKit = 0x0100005a,
5207  OBJImportOptionsKit = 0x0100005b,
5208  OBJImportResultsKit = 0x0100005c,
5209  STLImportOptionsKit = 0x0100005d,
5210  STLImportResultsKit = 0x0100005e,
5211  ShellOptimizationOptionsKit = 0x0100005f,
5212  ShellRelationOptionsKit = 0x01000060,
5213  ShellRelationResultsKit = 0x01000061,
5214  GridKit = 0x01000062,
5215  CutGeometryGatheringOptionsKit = 0x01000063,
5216  SegmentOptimizationOptionsKit = 0x01000064,
5217 
5218 
5219  LinePatternElement = 0x03000000,
5220  SolidLinePatternElement = 0x03000001,
5221  BlankLinePatternElement = 0x03000002,
5222  GlyphLinePatternElement = 0x03000003,
5223 
5224  GlyphElement = 0x05000000,
5225  DotGlyphElement = 0x05000001,
5226  LineGlyphElement = 0x05000002,
5227  EllipseGlyphElement = 0x05000003,
5228  CircularArcGlyphElement = 0x05000004,
5229  InfiniteLineGlyphElement = 0x05000005,
5230  SphereGlyphElement = 0x05000006,
5231 
5232  TrimElement = 0x07000000,
5233 
5234  Condition = 0x09000000,
5235  NOTCondition = 0x09000001,
5236  ANDCondition = 0x09000002,
5237  ORCondition = 0x09000003,
5238  XORCondition = 0x09000004,
5239  EQCondition = 0x09000005,
5240  NEQCondition = 0x09000006,
5241  GTCondition = 0x09000007,
5242  LTCondition = 0x09000008,
5243  GTEQCondition = 0x09000009,
5244  LTEQCondition = 0x0900000A,
5245 
5246  MouseState = 0x01001001,
5247  TouchState = 0x01001002,
5248  KeyboardState = 0x01001003,
5249  FontInfoState = 0x01001004,
5250 
5251  KeyPath = 0x01000F01,
5252 
5253  Key = 0x10000000,
5254  IncludeKey = 0x10000001,
5255  PortfolioKey = 0x10000002,
5256  StyleKey = 0x10000003,
5257 
5258  SegmentKey = 0x10200000,
5259  WindowKey = 0x10600000,
5260  StandAloneWindowKey = 0x10600001,
5261  OffScreenWindowKey = 0x10600002,
5262  ApplicationWindowKey = 0x10600003,
5263 
5264  GeometryKey = 0x10100000,
5265  ReferenceKey = 0x10100001,
5266  CircleKey = 0x10100002,
5267  CircularArcKey = 0x10100003,
5268  CircularWedgeKey = 0x10100004,
5269  CuttingSectionKey = 0x10100005,
5270  CylinderKey = 0x10100006,
5271  EllipseKey = 0x10100007,
5272  EllipticalArcKey = 0x10100008,
5273  InfiniteLineKey = 0x10100009,
5274  LineKey = 0x1010000a,
5275  DistantLightKey = 0x1010000b,
5276  SpotlightKey = 0x1010000c,
5277  MarkerKey = 0x1010000d,
5278  MeshKey = 0x1010000e,
5279  NURBSCurveKey = 0x1010000f,
5280  NURBSSurfaceKey = 0x10100010,
5281  PolygonKey = 0x10100011,
5282  ShellKey = 0x10100012,
5283  SphereKey = 0x10100013,
5284  TextKey = 0x10100014,
5285  GridKey = 0x10100015,
5286 
5287  Definition = 0x20000000,
5288  NamedStyleDefinition = 0x20000001,
5289  TextureDefinition = 0x20000002,
5290  LinePatternDefinition = 0x20000003,
5291  GlyphDefinition = 0x20000004,
5292  CubeMapDefinition = 0x20000005,
5293  ImageDefinition = 0x20000006,
5294  MaterialPaletteDefinition = 0x20000007,
5295  ShaderDefinition = 0x20000008,
5296 
5297  Control = 0x50000000,
5298  CameraControl = 0x50000001,
5299  SelectabilityControl = 0x50000002,
5300  MarkerAttributeControl = 0x50000003,
5301  SphereAttributeControl = 0x50000004,
5302  LightingAttributeControl = 0x50000005,
5303  CylinderAttributeControl = 0x50000006,
5304  TextAttributeControl = 0x50000007,
5305  LineAttributeControl = 0x50000008,
5306  EdgeAttributeControl = 0x50000009,
5307  CurveAttributeControl = 0x5000000a,
5308  ModellingMatrixControl = 0x5000000b,
5309  TextureMatrixControl = 0x5000000c,
5310  CullingControl = 0x5000000d,
5311  TransparencyControl = 0x5000000e,
5312  MaterialMappingControl = 0x5000000f,
5313  NURBSSurfaceAttributeControl = 0x50000010,
5314  PostProcessEffectsControl = 0x50000011,
5315  BoundingControl = 0x50000012,
5316  VisualEffectsControl = 0x50000013,
5317  SelectionOptionsControl = 0x50000014,
5318  HighlightOptionsControl = 0x50000015,
5319  DefinitionControl = 0x50000016,
5320  SelectionControl = 0x50000017,
5321  HighlightControl = 0x50000018,
5322  StandAloneWindowOptionsControl = 0x50000019,
5323  OffScreenWindowOptionsControl = 0x5000001a,
5324  ApplicationWindowOptionsControl = 0x5000001b,
5325  VisibilityControl = 0x5000001c,
5326  SubwindowControl = 0x5000001d,
5327  PerformanceControl = 0x5000001e,
5328  HiddenLineAttributeControl = 0x5000001f,
5329  DrawingAttributeControl = 0x50000020,
5330  DebuggingControl = 0x50000021,
5331  ContourLineControl = 0x50000022,
5332  StyleControl = 0x50000023,
5333  ConditionControl = 0x50000024,
5334  PortfolioControl = 0x50000025,
5335  WindowInfoControl = 0x50000026,
5336  AttributeLockControl = 0x50000027,
5337  TransformMaskControl = 0x50000028,
5338  ColorInterpolationControl = 0x50000029,
5339  UpdateOptionsControl = 0x50000030,
5340  CuttingSectionAttributeControl = 0x50000031,
5341 
5342  LibraryMask = 0x80FF0000,
5343 
5344  Sprocket = 0x80000000,
5345  Canvas = 0x80000001,
5346  Layout = 0x80000002,
5347  View = 0x80000003,
5348  Model = 0x80000004,
5349  Operator = 0x80000005,
5350  SprocketPath = 0x80000007,
5351 
5352  SprocketControl = 0xD0000000,
5353  OperatorControl = 0xD0000008,
5354  NavigationCubeControl = 0xD0000009,
5355  AxisTriadControl = 0xD000000A,
5356 
5357  Metadata = 0x80001000,
5358  IntegerMetadata = 0x80001001,
5359  UnsignedIntegerMetadata = 0x80001002,
5360  DoubleMetadata = 0x80001003,
5361  StringMetadata = 0x80001004,
5362  TimeMetadata = 0x80001005,
5363  BooleanMetadata = 0x80001006,
5364 
5365  Component = 0x80000200,
5366  Filter = 0x80000600,
5367  Capture = 0x80000a00,
5368  CADModel = 0x80000300,
5369  ComponentPath = 0x81001000,
5370 
5371  ExchangeMask = 0x80020000,
5372  ExchangeComponent = 0x80021200,
5373  ExchangeSheet = 0x80021201,
5374  ExchangeProductOccurrence = 0x80021202,
5375  ExchangeFilter = 0x80020601,
5376  ExchangeCapture = 0x80020a01,
5377  ExchangeCADModel = 0x80020301,
5378  ExchangeConfiguration = 0x81020001,
5379  ExchangeImportOptionsKit = 0x81020002,
5380  ExchangeExportACISOptionsKit = 0x81020003,
5381  ExchangeExportIGESOptionsKit = 0x81020004,
5382  ExchangeExportJTOptionsKit = 0x81020005,
5383  ExchangeExportParasolidOptionsKit = 0x81020006,
5384  ExchangeExportPRCOptionsKit = 0x81020007,
5385  ExchangeExportSTEPOptionsKit = 0x81020008,
5386  ExchangeExportSTLOptionsKit = 0x81020009,
5387  ExchangeExportU3DOptionsKit = 0x8102000a,
5388  ExchangeExportXMLOptionsKit = 0x8102000b,
5389  ExchangeTessellationOptionsKit = 0x8102000c,
5390  ExchangeModelFileImportOptionsKit = 0x8102000d,
5391  ExchangeTranslationOptionsKit = 0x8102000e,
5392 
5393  PublishMask = 0x80040000,
5394  PublishDocumentKit = 0x81040001,
5395  PublishPageKit = 0x81040002,
5396  PublishTemplateKit = 0x81040003,
5397  PublishAnnotationKit = 0x81040004,
5398  PublishArtworkKit = 0x81040005,
5399  PublishViewKit = 0x81040006,
5400  PublishTextKit = 0x81040007,
5401  PublishImageKit = 0x81040008,
5402  PublishTableKit = 0x81040009,
5403  PublishExportOptionsKit = 0x8104000a,
5404  PublishLinkKit = 0x8104000b,
5405  PublishButtonKit = 0x8104000c,
5406  PublishTextFieldKit = 0x8104000d,
5407  PublishSlideTableKit = 0x8104000e,
5408  PublishCheckBoxKit = 0x8104000f,
5409  PublishRadioButtonKit = 0x81040010,
5410  PublishListBoxKit = 0x81040011,
5411  PublishDropDownListKit = 0x81040012,
5412  PublishSignatureFieldKit = 0x81040013,
5413 
5414  PublishDocumentKey = 0x80040001,
5415  PublishPageControl = 0x80040002,
5416 
5417  SceneTree = 0x80008001,
5418  SceneTreeItem = 0x80008002,
5419 
5420  ComponentTree = 0x80008003,
5421  ComponentTreeItem = 0x80008004,
5422 
5423  SketchupMask = 0x80100000,
5424  SketchupImportOptionsKit = 0x81100001,
5425  SketchupImportResultsKit = 0x81100002,
5426 
5427  ParasolidMask = 0x80200000,
5428  ParasolidComponent = 0x80201201,
5429  ParasolidCADModel = 0x80200302,
5430  ParasolidImportOptionsKit = 0x81200003,
5431  ParasolidFacetTessellationKit = 0x81200004,
5432  ParasolidLineTessellationKit = 0x81200005,
5433  ParasolidExportOptionsKit = 0x81200006,
5434 
5435  DWGMask = 0x80400000,
5436  DWGComponent = 0x80401201,
5437  DWGLayer = 0x80401202,
5438  DWGLayout = 0x80400a03,
5439  DWGCADModel = 0x80400304,
5440  DWGImportOptionsKit = 0x81400005,
5441 
5442  IONotifierData = 0x84000200,
5443  StreamImportNotifierData = 0x84000201,
5444  STLImportNotifierData = 0x84000202,
5445  OBJImportNotifierData = 0x84000203,
5446  ExchangeImportNotifierData = 0x84020204,
5447  SketchupImportNotifierData = 0x84100205,
5448  ParasolidImportNotifierData = 0x84200206,
5449  ExchangeTranslationNotifierData = 0x84020207,
5450  ExchangeExportNotifierData = 0x84020208,
5451  StreamExportNotifierData = 0x84000209,
5452  DWGImportNotifierData = 0x8440020a,
5453 };
5454 
5456 class HPS_API Memory
5457 {
5458 public:
5464  static void * Allocate(size_t in_bytes, bool in_clear_memory = true);
5465 
5466 
5471  static void Free(void * in_pointer);
5472 
5473 private:
5475  Memory();
5476 };
5477 
5478 
5480 template <typename T>
5481 class NO_HPS_API Allocator
5482 {
5483 public:
5484  typedef T value_type;
5485  typedef value_type * pointer;
5486  typedef value_type const * const_pointer;
5487  typedef value_type & reference;
5488  typedef value_type const & const_reference;
5489  typedef size_t size_type;
5490  typedef ptrdiff_t difference_type;
5491 
5492 
5493  Allocator() {}
5494  Allocator(Allocator<T> const & in_that) { HPS_UNREFERENCED(in_that); }
5495  ~Allocator() {}
5496 
5497  template <typename U> Allocator(Allocator<U> const &) {}
5498 
5499  template <typename U>
5500  struct rebind
5501  {
5502  typedef Allocator<U> other;
5503  };
5504 
5505 
5506  pointer address(reference x) const { return &x; }
5507  const_pointer address(const_reference x) const { return &x; }
5508 
5509  pointer allocate(size_type n, void * v = 0) { HPS_UNREFERENCED(v); return static_cast<pointer>(Memory::Allocate(n * sizeof(T))); }
5510  void deallocate(pointer p, size_type n) { HPS_UNREFERENCED(n); Memory::Free(p); }
5511 
5512 #if defined(_MSC_VER) || defined (__APPLE__)
5513  void construct(pointer p, const_reference x) { new(p) T(x); }
5514  void construct(pointer p, value_type && x) { new(p) T(std::move(x)); }
5515 #else
5516  template<typename U, typename... Args>
5517  void construct(U * p, Args&&... args) { new(p) U(std::forward<Args>(args)...); }
5518 #endif
5519  void destroy(pointer p) { HPS_UNREFERENCED(p); p->~T(); }
5520 
5521  size_type max_size() const { return static_cast<size_type>(-1) / sizeof(T); }
5522 };
5523 
5524 template <typename T, typename U>
5525 bool operator==(const Allocator<T> &, const Allocator<U> &) { return true; }
5526 
5527 template <typename T, typename U>
5528 bool operator!=(const Allocator<T> &, const Allocator<U> &) { return false; }
5529 
5531 class Exception : public std::runtime_error
5532 {
5533 public:
5534  Exception(char const * in_info) : std::runtime_error(in_info) { }
5535 };
5536 
5537 
5540 {
5541 public:
5542  InvalidObjectException(char const * in_info = "Attempted to use a deleted, uninitialized, or otherwise invalid object.") :
5543  Exception(in_info) {}
5544 };
5545 
5546 
5550 {
5551 public:
5552  IndexOutOfRangeException(char const * in_info = "Attempted to access an element outside the bounds of the array.") :
5553  Exception(in_info) {}
5554 };
5555 
5556 
5559 {
5560 public:
5561  InvalidSpecificationException(char const * in_info = "Missing or invalid specification.") :
5562  Exception(in_info) {}
5563 };
5564 
5565 
5568 {
5569 public:
5570  InvalidLicenseException(char const * in_info) :
5571  Exception(in_info) {}
5572 };
5573 
5574 
5577 {
5578 public:
5579  InvalidOperationException(char const * in_info = "Operation not supported on this platform.") :
5580  Exception(in_info) {}
5581 };
5582 
5584 class IOException : public Exception
5585 {
5586 public:
5590  IOException(char const * in_info, IOResult in_result)
5591  : Exception(in_info), result(in_result) {}
5592 
5593  IOResult result;
5594 };
5595 
5596 
5598 class HPS_API Object
5599 {
5600 public:
5601 
5602  Object();
5603 
5604  Object(Object const & that);
5605 
5606  virtual ~Object();
5607 
5608  Object & operator=(Object const & other_object);
5609 
5613  Object(Object && in_that);
5614 
5615 
5619  Object & operator=(Object && in_that);
5620 
5624  HPS::Type Type() const;
5625 
5629  virtual HPS::Type ObjectType() const { return HPS::Type::None; }
5630 
5633  virtual bool Empty() const {return (impl_ == 0);};
5634 
5636  virtual void Reset();
5637 
5641  bool HasType(HPS::Type in_mask) const;
5642 
5645  intptr_t GetClassID() const;
5646 
5650  intptr_t GetInstanceID() const;
5651 
5654  template <typename T>
5655  static intptr_t ClassID()
5656  {
5657  static const intptr_t ret = T().GetClassID();
5658  return ret;
5659  }
5660 private:
5661 
5662  friend class HPSI::Impl;
5663  friend class HPSI::KeyImpl;
5664  friend class HPSI::TicketImpl;
5665 
5666  HPSI::Impl * impl_;
5667 };
5668 
5669 
5671 class HPS_API Control : public Object
5672 {
5673  HPS::Type ObjectType() const {return HPS::Type::Control;}
5674 
5675 public:
5676 
5677 #if !defined(_MSC_VER) || _MSC_VER >= 1900
5678  Control(Control const & in_that) = default;
5679 #endif
5680 
5681 protected:
5682  Control() {}
5683 
5687  Control(Control && in_that) : Object(std::move(in_that)) {}
5688 
5692  Control & operator=(Control && in_that)
5693  {
5694  this->Object::operator=(std::move(in_that));
5695  return *this;
5696  }
5697 
5698 };
5699 
5700 
5702 class HPS_API ObjectPoint : public Point
5703 {
5704 public:
5705 
5707  ObjectPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5708 
5710  ObjectPoint(Point const & in_point):Point(in_point){}
5711 
5713  ObjectPoint(WindowKey const & in_window, ObjectPoint const & in_point);
5714 
5716  ObjectPoint(WindowKey const & in_window, WorldPoint const & in_point);
5717 
5719  ObjectPoint(WindowKey const & in_window, CameraPoint const & in_point);
5720 
5722  ObjectPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5723 
5725  ObjectPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5726 
5728  ObjectPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5729 
5731  ObjectPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5732 
5734  ObjectPoint(WindowKey const & in_window, WindowPoint const & in_point);
5735 
5737  ObjectPoint(WindowKey const & in_window, PixelPoint const & in_point);
5738 
5739 private:
5740 
5741  ObjectPoint(WorldPoint const & in_point); // Prevent implicit conversion to other types of points
5742  ObjectPoint(CameraPoint const & in_point); // Prevent implicit conversion to other types of points
5743  ObjectPoint(NormalizedPoint const & in_point); // Prevent implicit conversion to other types of points
5744  ObjectPoint(ScreenRangePoint const & in_point); // Prevent implicit conversion to other types of points
5745  ObjectPoint(InnerWindowPoint const & in_point); // Prevent implicit conversion to other types of points
5746  ObjectPoint(InnerPixelPoint const & in_point); // Prevent implicit conversion to other types of points
5747  ObjectPoint(WindowPoint const & in_point); // Prevent implicit conversion to other types of points
5748  ObjectPoint(PixelPoint const & in_point); // Prevent implicit conversion to other types of points
5749 
5750 };
5751 
5753 class HPS_API WorldPoint : public Point
5754 {
5755 public:
5757  WorldPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5758 
5760  WorldPoint(Point const & in_point):Point(in_point){}
5761 
5763  WorldPoint(WindowKey const & in_window, ObjectPoint const & in_point);
5764 
5766  WorldPoint(WindowKey const & in_window, WorldPoint const & in_point);
5767 
5769  WorldPoint(WindowKey const & in_window, CameraPoint const & in_point);
5770 
5772  WorldPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5773 
5775  WorldPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5776 
5778  WorldPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5779 
5781  WorldPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5782 
5784  WorldPoint(WindowKey const & in_window, WindowPoint const & in_point);
5785 
5787  WorldPoint(WindowKey const & in_window, PixelPoint const & in_point);
5788 
5789 private:
5790 
5791  WorldPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
5792  WorldPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
5793  WorldPoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
5794  WorldPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
5795  WorldPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
5796  WorldPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
5797  WorldPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
5798  WorldPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
5799 
5800 };
5801 
5803 class HPS_API CameraPoint : public Point
5804 {
5805 public:
5807  CameraPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5808 
5810  CameraPoint(Point const & in_point):Point(in_point){}
5811 
5813  CameraPoint(WindowKey const & in_window, ObjectPoint const & in_point);
5814 
5816  CameraPoint(WindowKey const & in_window, WorldPoint const & in_point);
5817 
5819  CameraPoint(WindowKey const & in_window, CameraPoint const & in_point);
5820 
5822  CameraPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5823 
5825  CameraPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5826 
5828  CameraPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5829 
5831  CameraPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5832 
5834  CameraPoint(WindowKey const & in_window, WindowPoint const & in_point);
5835 
5837  CameraPoint(WindowKey const & in_window, PixelPoint const & in_point);
5838 
5839 private:
5840  CameraPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
5841  CameraPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
5842  CameraPoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
5843  CameraPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
5844  CameraPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
5845  CameraPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
5846  CameraPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
5847  CameraPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
5848 
5849 };
5850 
5852 class HPS_API NormalizedPoint : public Point
5853 {
5854 public:
5855 
5857  NormalizedPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5858 
5860  NormalizedPoint(Point const & in_point):Point(in_point){}
5861 
5863  NormalizedPoint(WindowKey const & in_window, ObjectPoint const & in_point);
5864 
5866  NormalizedPoint(WindowKey const & in_window, WorldPoint const & in_point);
5867 
5869  NormalizedPoint(WindowKey const & in_window, CameraPoint const & in_point);
5870 
5872  NormalizedPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5873 
5875  NormalizedPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5876 
5878  NormalizedPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5879 
5881  NormalizedPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5882 
5884  NormalizedPoint(WindowKey const & in_window, WindowPoint const & in_point);
5885 
5887  NormalizedPoint(WindowKey const & in_window, PixelPoint const & in_point);
5888 
5889 private:
5890  NormalizedPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
5891  NormalizedPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
5892  NormalizedPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
5893  NormalizedPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
5894  NormalizedPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
5895  NormalizedPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
5896  NormalizedPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
5897  NormalizedPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
5898 };
5899 
5901 class HPS_API ScreenRangePoint : public Point
5902 {
5903 public:
5905  ScreenRangePoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5906 
5908  ScreenRangePoint(Point const & in_point):Point(in_point){}
5909 
5911  ScreenRangePoint(WindowKey const & in_window, ObjectPoint const & in_point);
5912 
5914  ScreenRangePoint(WindowKey const & in_window, WorldPoint const & in_point);
5915 
5917  ScreenRangePoint(WindowKey const & in_window, CameraPoint const & in_point);
5918 
5920  ScreenRangePoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5921 
5923  ScreenRangePoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5924 
5926  ScreenRangePoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5927 
5929  ScreenRangePoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5930 
5932  ScreenRangePoint(WindowKey const & in_window, WindowPoint const & in_point);
5933 
5935  ScreenRangePoint(WindowKey const & in_window, PixelPoint const & in_point);
5936 
5937 private:
5938  ScreenRangePoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
5939  ScreenRangePoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
5940  ScreenRangePoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
5941  ScreenRangePoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
5942  ScreenRangePoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
5943  ScreenRangePoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
5944  ScreenRangePoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
5945  ScreenRangePoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
5946 
5947 };
5948 
5950 class HPS_API InnerWindowPoint : public Point
5951 {
5952 public:
5953 
5955  InnerWindowPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5956 
5958  InnerWindowPoint(Point const & in_point):Point(in_point){}
5959 
5961  InnerWindowPoint(WindowKey const & in_window, ObjectPoint const & in_point);
5962 
5964  InnerWindowPoint(WindowKey const & in_window, WorldPoint const & in_point);
5965 
5967  InnerWindowPoint(WindowKey const & in_window, CameraPoint const & in_point);
5968 
5970  InnerWindowPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5971 
5973  InnerWindowPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5974 
5976  InnerWindowPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5977 
5979  InnerWindowPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5980 
5982  InnerWindowPoint(WindowKey const & in_window, WindowPoint const & in_point);
5983 
5985  InnerWindowPoint(WindowKey const & in_window, PixelPoint const & in_point);
5986 
5987 private:
5988  InnerWindowPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
5989  InnerWindowPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
5990  InnerWindowPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
5991  InnerWindowPoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
5992  InnerWindowPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
5993  InnerWindowPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
5994  InnerWindowPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
5995  InnerWindowPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
5996 };
5997 
5999 class HPS_API InnerPixelPoint : public Point
6000 {
6001 public:
6002 
6004  InnerPixelPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
6005 
6007  InnerPixelPoint(Point const & in_point):Point(in_point){}
6008 
6010  InnerPixelPoint(WindowKey const & in_window, ObjectPoint const & in_point);
6011 
6013  InnerPixelPoint(WindowKey const & in_window, WorldPoint const & in_point);
6014 
6016  InnerPixelPoint(WindowKey const & in_window, CameraPoint const & in_point);
6017 
6019  InnerPixelPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
6020 
6022  InnerPixelPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
6023 
6025  InnerPixelPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
6026 
6028  InnerPixelPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
6029 
6031  InnerPixelPoint(WindowKey const & in_window, WindowPoint const & in_point);
6032 
6034  InnerPixelPoint(WindowKey const & in_window, PixelPoint const & in_point);
6035 
6036 private:
6037  InnerPixelPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
6038  InnerPixelPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
6039  InnerPixelPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
6040  InnerPixelPoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
6041  InnerPixelPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
6042  InnerPixelPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
6043  InnerPixelPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
6044  InnerPixelPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
6045 
6046 };
6047 
6049 class HPS_API WindowPoint : public Point
6050 {
6051 public:
6052 
6054  WindowPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
6055 
6057  WindowPoint(Point const & in_point):Point(in_point){}
6058 
6060  WindowPoint(WindowKey const & in_window, ObjectPoint const & in_point);
6061 
6063  WindowPoint(WindowKey const & in_window, WorldPoint const & in_point);
6064 
6066  WindowPoint(WindowKey const & in_window, CameraPoint const & in_point);
6067 
6069  WindowPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
6070 
6072  WindowPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
6073 
6075  WindowPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
6076 
6078  WindowPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
6079 
6081  WindowPoint(WindowKey const & in_window, WindowPoint const & in_point);
6082 
6084  WindowPoint(WindowKey const & in_window, PixelPoint const & in_point);
6085 
6086 private:
6087  WindowPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
6088  WindowPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
6089  WindowPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
6090  WindowPoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
6091  WindowPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
6092  WindowPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
6093  WindowPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
6094  WindowPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
6095 };
6096 
6097 
6099 class HPS_API PixelPoint : public Point
6100 {
6101 public:
6103  PixelPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
6104 
6106  PixelPoint(Point const & in_point):Point(in_point){}
6107 
6109  PixelPoint(WindowKey const & in_window, ObjectPoint const & in_point);
6110 
6112  PixelPoint(WindowKey const & in_window, WorldPoint const & in_point);
6113 
6115  PixelPoint(WindowKey const & in_window, CameraPoint const & in_point);
6116 
6118  PixelPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
6119 
6121  PixelPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
6122 
6124  PixelPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
6125 
6127  PixelPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
6128 
6130  PixelPoint(WindowKey const & in_window, WindowPoint const & in_point);
6131 
6133  PixelPoint(WindowKey const & in_window, PixelPoint const & in_point);
6134 
6135 private:
6136  PixelPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
6137  PixelPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
6138  PixelPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
6139  PixelPoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
6140  PixelPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
6141  PixelPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
6142  PixelPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
6143  PixelPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
6144 
6145 };
6146 
6149 class HPS_API Event
6150 {
6151 public:
6155  enum class Status
6156  {
6157  InProgress,
6158  Completed,
6159  Failed
6160  };
6161 
6163  Event(intptr_t in_channel = 0): channel(in_channel), consumable(true), time_stamp(0) {}
6164 
6165  virtual ~Event();
6166 
6168  intptr_t GetClassID() const;
6169 
6172  virtual Event * Clone() const=0;
6173 
6175  virtual bool Drop(Event const * in_that_event) const { HPS_UNREFERENCED(in_that_event); return false; }
6176 
6179  virtual intptr_t Freshen() const { return 0; }
6180 
6182  intptr_t GetChannel() const { return channel; }
6183 
6185  Time GetTimeStamp() const { return time_stamp; }
6186 
6188  bool IsConsumable() const { return consumable; }
6189 
6190  static void * operator new (size_t in_size) { return Memory::Allocate(in_size); }
6191  static void operator delete (void * in_ptr, size_t in_size) throw () { HPS_UNREFERENCED(in_size); Memory::Free(in_ptr); }
6192 
6193 protected:
6194  intptr_t channel;
6195  bool consumable;
6196 
6197 private:
6198  friend class HPSI::EventDispatcherImpl;
6199  Time time_stamp;
6200 };
6201 
6202 
6205 class HPS_API EventNotifier : public Object
6206 {
6207 public:
6208 
6210  EventNotifier();
6211 
6214  EventNotifier(EventNotifier const & in_that);
6215 
6219  EventNotifier(EventNotifier && in_that);
6220 
6224  EventNotifier & operator=(EventNotifier && in_that);
6225 
6226  virtual ~EventNotifier();
6227 
6228  HPS::Type ObjectType() const {return HPS::Type::EventNotifier;};
6229 
6233  EventNotifier & operator=(EventNotifier const & in_that);
6234 
6237  virtual void Assign(EventNotifier const & in_that);
6238 
6240  void Wait() const;
6241 
6244  Event::Status Status() const;
6245 };
6246 
6248 enum class KeyboardCode
6249 {
6250  None = 0,
6251 
6252  Backspace = 8,
6253  Tab = 9,
6254  Clear = 11,
6255  Return = 13,
6256  Shift = 16,
6257  Control = 17,
6258  Alt = 18,
6259  Pause = 19,
6260  Escape = 27,
6261 
6262  Space = 32,
6263  ExclamationMark,
6264  DoubleQuote,
6265  Number,
6266  Dollar,
6267  Percent,
6268  Ampersand,
6269  SingleQuote,
6270  OpenParen,
6271  CloseParen,
6272 
6273  Asterisk,
6274  Plus,
6275  Comma,
6276  Hyphen,
6277  Period,
6278  Slash,
6279 
6280  D0,
6281  D1,
6282  D2,
6283  D3,
6284  D4,
6285  D5,
6286  D6,
6287  D7,
6288  D8,
6289  D9,
6290 
6291  Colon,
6292  Semicolon,
6293  LessThan,
6294  Equal,
6295  GreaterThan,
6296  QuestionMark,
6297  AtSymbol,
6298 
6299  A,
6300  B,
6301  C,
6302  D,
6303  E,
6304  F,
6305  G,
6306  H,
6307  I,
6308  J,
6309  K,
6310  L,
6311  M,
6312  N,
6313  O,
6314  P,
6315  Q,
6316  R,
6317  S,
6318  T,
6319  U,
6320  V,
6321  W,
6322  X,
6323  Y,
6324  Z,
6325 
6326  OpenBrackets,
6327  Backslash,
6328  CloseBrackets,
6329  Caret,
6330  Underscore,
6331  Backtick,
6332 
6333  a,
6334  b,
6335  c,
6336  d,
6337  e,
6338  f,
6339  g,
6340  h,
6341  i,
6342  j,
6343  k,
6344  l,
6345  m,
6346  n,
6347  o,
6348  p,
6349  q,
6350  r,
6351  s,
6352  t,
6353  u,
6354  v,
6355  w,
6356  x,
6357  y,
6358  z,
6359 
6360  OpenBrace,
6361  VerticalBar,
6362  ClosingBrace,
6363  Tilde,
6364  Delete,
6365 
6366  Insert=1024,
6367  Home,
6368  End,
6369  PageUp,
6370  PageDown,
6371 
6372  Help,
6373 
6374  Left,
6375  Up,
6376  Right,
6377  Down,
6378 
6379  NumPad0,
6380  NumPad1,
6381  NumPad2,
6382  NumPad3,
6383  NumPad4,
6384  NumPad5,
6385  NumPad6,
6386  NumPad7,
6387  NumPad8,
6388  NumPad9,
6389 
6390  F1,
6391  F2,
6392  F3,
6393  F4,
6394  F5,
6395  F6,
6396  F7,
6397  F8,
6398  F9,
6399  F10,
6400  F11,
6401  F12,
6402  F13,
6403  F14,
6404  F15,
6405  F16,
6406  F17,
6407  F18,
6408  F19,
6409  F20,
6410  F21,
6411  F22,
6412  F23,
6413  F24,
6414 
6415  // these are not implemented
6416 // CapsLock, //!< The Caps Lock key.
6417 //
6418 // NumLock, //!< The Num Lock key.
6419 // ScrollLock, //!< The Scroll Lock key.
6420 // LeftShift, //!< The left Shift key.
6421 // RightShift, //!< The right Shift key.
6422 // LeftCtrl, //!< The left CTRL key.
6423 // RightCtrl, //!< The right CTRL key.
6424 // LeftAlt, //!< The left ALT key.
6425 // RightAlt, //!< The right ALT key.
6426 //
6427 // Select, //!< The Select key.
6428 // Print, //!< The Print key.
6429 // Execute, //!< The Execute key.
6430 // PrintScreen, //!< The Print Screen key.
6431 };
6432 
6433 
6435 class NO_HPS_API Touch
6436 {
6437 public:
6438 
6441  Touch() : ID(0), Location(Point(0,0,0)), TapCount(0) {}
6442 
6447  Touch(TouchID in_id, WindowPoint const & in_location, size_t in_tap_count = 1)
6448  : ID(in_id), Location(in_location), TapCount(in_tap_count) {}
6449 
6453  inline bool operator==(Touch const & in_that) const
6454  {
6455  return (ID == in_that.ID && Location == in_that.Location && TapCount == in_that.TapCount);
6456  }
6457 
6461  inline bool operator!=(Touch const & in_that) const
6462  {
6463  return !(*this == in_that);
6464  }
6465 
6466  TouchID ID;
6468  size_t TapCount;
6469 };
6470 
6471 
6472 typedef std::vector<Point, Allocator<Point> > PointArray;
6473 typedef std::vector<ObjectPoint, Allocator<ObjectPoint> > ObjectPointArray;
6474 typedef std::vector<WorldPoint, Allocator<WorldPoint> > WorldPointArray;
6475 typedef std::vector<CameraPoint, Allocator<CameraPoint> > CameraPointArray;
6476 typedef std::vector<NormalizedPoint, Allocator<NormalizedPoint> > NormalizedPointArray;
6477 typedef std::vector<ScreenRangePoint, Allocator<ScreenRangePoint> > ScreenRangePointArray;
6478 typedef std::vector<InnerWindowPoint, Allocator<InnerWindowPoint> > InnerWindowPointArray;
6479 typedef std::vector<InnerPixelPoint, Allocator<InnerPixelPoint> > InnerPixelPointArray;
6480 typedef std::vector<WindowPoint, Allocator<WindowPoint> > WindowPointArray;
6481 typedef std::vector<PixelPoint, Allocator<PixelPoint> > PixelPointArray;
6482 typedef std::vector<Vector, Allocator<Vector> > VectorArray;
6483 typedef std::vector<DVector, Allocator<DVector> > DVectorArray;
6484 typedef std::vector<Plane, Allocator<Plane> > PlaneArray;
6485 typedef std::vector<int, Allocator<int> > IntArray;
6486 typedef std::vector<RGBColor, Allocator<RGBColor> > RGBColorArray;
6487 typedef std::vector<RGBAColor, Allocator<RGBAColor> > RGBAColorArray;
6488 typedef std::vector<unsigned int, Allocator<unsigned int> > UnsignedIntArray;
6489 typedef std::vector<size_t, Allocator<size_t> > SizeTArray;
6490 typedef std::vector<float, Allocator<float> > FloatArray;
6491 typedef std::vector<SegmentKey, Allocator<SegmentKey> > SegmentKeyArray;
6492 typedef std::vector<WindowKey, Allocator<WindowKey> > WindowKeyArray;
6493 typedef std::vector<EventHandler, Allocator<EventHandler> > EventHandlerArray;
6494 typedef std::vector<GlyphElement, Allocator<GlyphElement> > GlyphElementArray;
6495 typedef std::vector<GlyphPoint, Allocator<GlyphPoint> > GlyphPointArray;
6496 typedef std::vector<UTF8, Allocator<UTF8> > UTF8Array;
6497 typedef std::vector<UTF8Array, Allocator<UTF8Array> > UTF8ArrayArray;
6498 typedef std::vector<bool, Allocator<bool> > BoolArray;
6499 typedef std::vector<TrimKit, Allocator<TrimKit> > TrimKitArray;
6500 typedef std::vector<Key, Allocator<Key> > KeyArray;
6501 typedef std::vector<PortfolioKey, Allocator<PortfolioKey> > PortfolioKeyArray;
6502 typedef std::vector<char, Allocator<char> > CharArray;
6503 typedef std::vector<wchar_t, Allocator<wchar_t> > WCharArray;
6504 typedef std::vector<byte, Allocator<byte> > ByteArray;
6505 typedef std::vector<ByteArray, Allocator<ByteArray> > ByteArrayArray;
6506 typedef std::vector<sbyte, Allocator<sbyte> > SByteArray;
6507 typedef std::vector<MaterialKit, Allocator<MaterialKit> > MaterialKitArray;
6508 typedef std::vector<LinePatternElement, Allocator<LinePatternElement> > LinePatternElementArray;
6509 typedef std::vector<LinePatternParallelKit, Allocator<LinePatternParallelKit> > LinePatternParallelKitArray;
6510 typedef std::vector<Material::Type, Allocator<Material::Type> > MaterialTypeArray;
6511 typedef std::vector<Search::Type, Allocator<Search::Type> > SearchTypeArray;
6512 typedef std::vector<Line::SizeUnits, Allocator<Line::SizeUnits> > LineSizeUnitsArray;
6513 typedef std::vector<CameraKit, Allocator<CameraKit> > CameraKitArray;
6514 typedef std::vector<Condition, Allocator<Condition> > ConditionArray;
6515 typedef std::vector<TextureDefinition, Allocator<TextureDefinition> > TextureDefinitionArray;
6516 typedef std::vector<CubeMapDefinition, Allocator<CubeMapDefinition> > CubeMapDefinitionArray;
6517 typedef std::vector<ImageDefinition, Allocator<ImageDefinition> > ImageDefinitionArray;
6518 typedef std::vector<NamedStyleDefinition, Allocator<NamedStyleDefinition> > NamedStyleDefinitionArray;
6519 typedef std::vector<MaterialPaletteDefinition, Allocator<MaterialPaletteDefinition> > MaterialPaletteDefinitionArray;
6520 typedef std::vector<GlyphDefinition, Allocator<GlyphDefinition> > GlyphDefinitionArray;
6521 typedef std::vector<LinePatternDefinition, Allocator<LinePatternDefinition> > LinePatternDefinitionArray;
6522 typedef std::vector<ShaderDefinition, Allocator<ShaderDefinition> > ShaderDefinitionArray;
6523 typedef std::vector<IntRectangle, Allocator<IntRectangle> > IntRectangleArray;
6524 typedef std::vector<AttributeLock::Type, Allocator<AttributeLock::Type> > AttributeLockTypeArray;
6525 typedef std::vector<Style::Type, Allocator<Style::Type> > StyleTypeArray;
6526 typedef std::vector<TrimElement, Allocator<TrimElement> > TrimElementArray;
6527 typedef std::vector<KeyPath, Allocator<KeyPath> > KeyPathArray;
6528 typedef std::vector<IncludeKey, Allocator<IncludeKey> > IncludeKeyArray;
6529 typedef std::vector<KeyboardCode, Allocator<KeyboardCode> > KeyboardCodeArray;
6530 typedef std::vector<Touch, Allocator<Touch> > TouchArray;
6531 typedef std::vector<ReferenceKey, Allocator<ReferenceKey> > ReferenceKeyArray;
6532 typedef std::vector<intptr_t, Allocator<intptr_t> > IntPtrTArray;
6533 typedef std::vector<GeometryKey, Allocator<GeometryKey> > GeometryKeyArray;
6534 typedef std::vector<Shell::Relation, Allocator<Shell::Relation> > ShellRelationArray;
6535 typedef std::vector<StyleKey, Allocator<StyleKey> > StyleKeyArray;
6536 typedef std::vector<PointArray, Allocator<PointArray> > PointArrayArray;
6537 
6538 
6540 class HPS_API SearchResultsIterator : public Object
6541 {
6542 public:
6543 
6546 
6550  SearchResultsIterator(SearchResultsIterator const & in_search_results_iterator);
6551 
6556 
6560  SearchResultsIterator & operator=(SearchResultsIterator && in_that);
6561 
6563 
6564  HPS::Type ObjectType() const {return HPS::Type::SearchResultsIterator;}
6565 
6570  SearchResultsIterator & operator=(SearchResultsIterator const & in_search_results_iterator);
6571 
6576  void Set(SearchResultsIterator const & in_search_results_iterator);
6577 
6579  void Next();
6580 
6583  SearchResultsIterator & operator++();
6584 
6587  SearchResultsIterator operator++(int in_val);
6588 
6591  bool operator==(SearchResultsIterator const & in_search_results_iterator);
6592 
6595  bool operator!=(SearchResultsIterator const & in_search_results_iterator);
6596 
6600  bool IsValid() const;
6601 
6603  void Reset();
6604 
6608  Key GetItem() const;
6609 
6612  Key operator*() const;
6613 
6616  SearchTypeArray GetResultTypes() const;
6617 };
6618 
6620 class HPS_API SearchResults : public Object
6621 {
6622 public:
6624  SearchResults();
6625 
6628  SearchResults(SearchResults const & in_search_results);
6629 
6633  SearchResults(SearchResults && in_that);
6634 
6638  SearchResults & operator=(SearchResults && in_that);
6639 
6641  virtual void Reset();
6642 
6644  ~SearchResults();
6645 
6646  HPS::Type ObjectType() const {return HPS::Type::SearchResults;}
6647 
6651  void Assign(SearchResults const & in_search_results);
6652 
6656  SearchResults & operator=(SearchResults const & in_search_results);
6657 
6660  size_t GetCount() const;
6661 
6664  SearchResultsIterator GetIterator() const;
6665 };
6666 
6668 class HPS_API FontSearchResultsIterator : public Object
6669 {
6670 public:
6671 
6674 
6678  FontSearchResultsIterator(FontSearchResultsIterator const & in_search_results_iterator);
6679 
6684 
6689  FontSearchResultsIterator & operator=(FontSearchResultsIterator const & in_search_results_iterator);
6690 
6691 
6695  FontSearchResultsIterator & operator=(FontSearchResultsIterator && in_that);
6696 
6698 
6699  HPS::Type ObjectType() const {return HPS::Type::FontSearchResultsIterator;}
6700 
6701 
6706  void Set(FontSearchResultsIterator const & in_search_results_iterator);
6707 
6709  void Next();
6710 
6713  FontSearchResultsIterator & operator++();
6714 
6717  FontSearchResultsIterator operator++(int in_val);
6718 
6721  bool operator==(FontSearchResultsIterator const & in_search_results_iterator);
6722 
6725  bool operator!=(FontSearchResultsIterator const & in_search_results_iterator);
6726 
6730  bool IsValid() const;
6731 
6733  void Reset();
6734 
6738  FontInfoState GetItem() const;
6739 
6742  FontInfoState operator*() const;
6743 
6744 };
6745 
6747 class HPS_API FontSearchResults : public Object
6748 {
6749 public:
6750 
6753 
6756  FontSearchResults(FontSearchResults const & in_search_results);
6757 
6762 
6766  FontSearchResults & operator=(FontSearchResults && in_that);
6767 
6769  virtual void Reset();
6770 
6772  ~FontSearchResults();
6773 
6774  HPS::Type ObjectType() const {return HPS::Type::FontSearchResults;}
6775 
6779  void Assign(FontSearchResults const & in_search_results);
6780 
6781 
6785  FontSearchResults & operator=(FontSearchResults const & in_search_results);
6786 
6789  size_t GetCount() const;
6790 
6793  FontSearchResultsIterator GetIterator() const;
6794 };
6795 
6797 class HPS_API UTF8
6798 {
6799 public:
6800 
6802  UTF8();
6803 
6805  ~UTF8();
6806 
6813  UTF8(char const * in_string, char const * in_locale = 0);
6814 
6817  UTF8(wchar_t const * in_string);
6818 
6821  UTF8(UTF8 const & in_that);
6822 
6825  UTF8(UTF8 && in_that);
6826 
6830  UTF8 & Assign(UTF8 && in_utf8);
6831 
6834  inline UTF8 & operator= (UTF8 && in_utf8)
6835  {
6836  return Assign(std::move(in_utf8));
6837  }
6838 
6843  size_t ToWStr(wchar_t * out_wide_string) const;
6844 
6848  size_t ToWStr(WCharArray & out_wide_string) const;
6849 
6852  inline bool IsValid() const
6853  {
6854  return (_length > 0);
6855  }
6856 
6859  inline bool Empty() const
6860  {
6861  return (_length == 0);
6862  }
6863 
6865  void Clear();
6866 
6868  void Reset() { Clear(); }
6869 
6873  inline size_t GetLength() const
6874  {
6875  return _length;
6876  }
6877 
6881  inline size_t GetWStrLength() const
6882  {
6883  return ToWStr(0);
6884  }
6885 
6888  inline char const * GetBytes() const
6889  {
6890  return _text;
6891  }
6892 
6895  inline operator char const * () const
6896  {
6897  return _text;
6898  }
6899 
6902  char At(size_t in_index) const
6903  {
6904  if(!IsValid())
6905  throw InvalidObjectException();
6906  else if(in_index >= _length)
6907  throw IndexOutOfRangeException();
6908  else
6909  return _text[in_index];
6910  }
6911 
6915  UTF8 & Assign(UTF8 const & in_utf8);
6916 
6920  inline UTF8 & operator= (UTF8 const & in_utf8)
6921  {
6922  return Assign(in_utf8);
6923  }
6924 
6928  UTF8 & operator+= (UTF8 const & in_utf8);
6929 
6933  UTF8 & operator+= (char const * in_utf8);
6934 
6938  UTF8 operator+ (UTF8 const & in_utf8) const;
6939 
6943  UTF8 operator+ (char const * in_utf8) const;
6944 
6948  bool operator== (UTF8 const & in_utf8) const;
6949 
6953  bool operator!= (UTF8 const & in_utf8) const
6954  {
6955  return !(*this == in_utf8);
6956  }
6957 
6961  bool operator== (char const * in_utf8) const;
6962 
6966  bool operator!= (char const * in_utf8) const
6967  {
6968  return !(*this == in_utf8);
6969  }
6970 
6975  friend inline bool operator==(char const * in_left, UTF8 const & in_right)
6976  {
6977  return in_right == in_left;
6978  }
6979 
6984  friend inline bool operator!=(char const * in_left, UTF8 const & in_right)
6985  {
6986  return in_right != in_left;
6987  }
6988 
6993  friend inline bool operator==(wchar_t const * in_left, UTF8 const & in_right)
6994  {
6995  return in_right == UTF8(in_left);
6996  }
6997 
7002  friend bool operator!=(wchar_t const * in_left, UTF8 const & in_right)
7003  {
7004  return in_right != UTF8(in_left);
7005  }
7006 
7011  friend inline UTF8 operator+ (char const * in_left, UTF8 const & in_right)
7012  {
7013  return UTF8(in_left) + in_right;
7014  }
7015 
7020  friend inline UTF8 operator+ (wchar_t const * in_left, UTF8 const & in_right)
7021  {
7022  return UTF8(in_left) + in_right;
7023  }
7024 
7025 
7028  size_t GetHash() const;
7029 
7030 private:
7031 
7032  size_t internal_encode(wchar_t const * in_wide_string);
7033  size_t internal_decode(wchar_t * out_wide_string) const;
7034 
7035  char * _text;
7036  size_t _length;
7037  mutable size_t _hash_key;
7038  static const size_t _buffer_size = 64 - sizeof(const char *) - 2 * sizeof(size_t);
7039  char _buffer[_buffer_size];
7040 };
7041 
7043 struct UTF8Hasher {
7044  inline size_t operator()(const HPS::UTF8 & in_utf8) const
7045  {
7046  return in_utf8.GetHash();
7047  }
7048 };
7049 
7052 class HPS_API Condition : public Object
7053 {
7054 public:
7055 
7056  enum class Intrinsic
7057  {
7058  Extent,
7059  DrawPass
7060  };
7061 
7063  Condition();
7064 
7067  Condition(char const * in_utf8);
7068 
7071  Condition(float in_number);
7072 
7075  Condition(HPS::Condition::Intrinsic in_special);
7076 
7079  Condition(Condition const & in_that);
7080 
7084  Condition(Condition && in_that);
7085 
7089  Condition & operator=(Condition && in_that);
7090 
7091  HPS::Type ObjectType() const { return HPS::Type::Condition; }
7092 
7096  bool ShowCondition(UTF8 & out_condition) const;
7097 
7101  bool ShowNumber(float & out_number) const;
7102 
7106  bool ShowIntrinsic(Condition::Intrinsic & out_special) const;
7107 
7111  bool ShowOperands(ConditionArray & out_operands) const;
7112 
7116  Condition & operator=(Condition const & in_that);
7117 
7121  bool Equals(Condition const & in_that) const;
7122 
7126  bool operator==(Condition const & in_that) const;
7127 
7131  bool operator!=(Condition const & in_that) const;
7132 
7136  bool IsSatisfiedBy(UTF8Array const & in_conditions) const;
7137 
7141  bool IsSatisfiedBy(char const * in_condition) const;
7142 
7146  Condition OR(Condition const & in_operand2) const;
7147 
7151  Condition XOR(Condition const & in_operand2) const;
7152 
7156  Condition AND(Condition const & in_operand2) const;
7157 
7161  Condition EQ(Condition const & in_operand2) const;
7162 
7166  Condition NEQ(Condition const & in_operand2) const;
7167 
7171  Condition GT(Condition const & in_operand2) const;
7172 
7176  Condition LT(Condition const & in_operand2) const;
7177 
7181  Condition GTEQ(Condition const & in_operand2) const;
7182 
7186  Condition LTEQ(Condition const & in_operand2) const;
7187 
7190  Condition operator !() const;
7191 
7195  Condition operator ||(Condition const & in_operand2) const;
7196 
7200  Condition operator ^(Condition const & in_operand2) const;
7201 
7205  Condition operator &&(Condition const & in_operand2) const;
7206 
7207 
7211  static Condition NOT(Condition const & in_operand);
7212 
7217  static Condition OR(Condition const & in_operand1, Condition const & in_operand2);
7218 
7219 
7224  static Condition XOR(Condition const & in_operand1, Condition const & in_operand2);
7225 
7230  static Condition AND(Condition const & in_operand1, Condition const & in_operand2);
7231 
7236  static Condition EQ(Condition const & in_operand1, Condition const & in_operand2);
7237 
7242  static Condition NEQ(Condition const & in_operand1, Condition const & in_operand2);
7243 
7248  static Condition GT(Condition const & in_operand1, Condition const & in_operand2);
7249 
7254  static Condition LT(Condition const & in_operand1, Condition const & in_operand2);
7255 
7260  static Condition GTEQ(Condition const & in_operand1, Condition const & in_operand2);
7261 
7266  static Condition LTEQ(Condition const & in_operand1, Condition const & in_operand2);
7267 
7268  friend HPS_API Condition NOT(Condition const & in_operand);
7269  friend HPS_API Condition OR(Condition const & in_operand1, Condition const & in_operand2);
7270  friend HPS_API Condition XOR(Condition const & in_operand1, Condition const & in_operand2);
7271  friend HPS_API Condition AND(Condition const & in_operand1, Condition const & in_operand2);
7272 
7273  friend HPS_API Condition EQ(Condition const & in_operand1, Condition const & in_operand2);
7274  friend HPS_API Condition NEQ(Condition const & in_operand1, Condition const & in_operand2);
7275  friend HPS_API Condition GT(Condition const & in_operand1, Condition const & in_operand2);
7276  friend HPS_API Condition LT(Condition const & in_operand1, Condition const & in_operand2);
7277  friend HPS_API Condition GTEQ(Condition const & in_operand1, Condition const & in_operand2);
7278  friend HPS_API Condition LTEQ(Condition const & in_operand1, Condition const & in_operand2);
7279 };
7280 
7281 
7285 HPS_API Condition NOT(Condition const & in_operand);
7286 
7291 HPS_API Condition OR(Condition const & in_operand1, Condition const & in_operand2);
7292 
7297 HPS_API Condition XOR(Condition const & in_operand1, Condition const & in_operand2);
7298 
7303 HPS_API Condition AND(Condition const & in_operand1, Condition const & in_operand2);
7304 
7309 HPS_API Condition EQ(Condition const & in_operand1, Condition const & in_operand2);
7310 
7315 HPS_API Condition NEQ(Condition const & in_operand1, Condition const & in_operand2);
7316 
7321 HPS_API Condition GT(Condition const & in_operand1, Condition const & in_operand2);
7322 
7327 HPS_API Condition LT(Condition const & in_operand1, Condition const & in_operand2);
7328 
7333 HPS_API Condition GTEQ(Condition const & in_operand1, Condition const & in_operand2);
7334 
7339 HPS_API Condition LTEQ(Condition const & in_operand1, Condition const & in_operand2);
7340 
7341 
7342 
7346 class HPS_API Key : public Object
7347 {
7348 public:
7349 
7351  Key();
7352 
7354  Key(Key const & in_that);
7355 
7357  explicit Key(Control const & in_control);
7358 
7362  Key(Key && in_that);
7363 
7367  Key & operator=(Key && in_that);
7368 
7370  virtual ~Key();
7371 
7372  HPS::Type ObjectType() const {return HPS::Type::Key;};
7373 
7375  bool HasOwner() const;
7376 
7378  SegmentKey Up() const;
7379 
7381  SegmentKey Owner() const;
7382 
7384  void Delete();
7385 
7387  void MoveTo(SegmentKey const & in_new_owner);
7388 
7391  Key CopyTo(SegmentKey const & in_destination) const;
7392 
7396  Key & operator=(Key const & in_that);
7397 
7400  virtual void Assign(Key const & in_that);
7401 
7403  bool Equals(Key const & in_that) const;
7404 
7406  bool operator!= (Key const & in_that) const;
7407 
7409  bool operator== (Key const & in_that) const;
7410 
7413  size_t GetHash() const;
7414 };
7415 
7417 struct KeyHasher {
7418  inline size_t operator()(const HPS::Key & in_key) const
7419  {
7420  return in_key.GetHash();
7421  }
7422 };
7423 
7424 
7427 class HPS_API SegmentKey : public Key
7428 {
7429 public:
7431  SegmentKey();
7432 
7434  SegmentKey(SegmentKey const & in_that);
7435 
7437  SegmentKey & operator=(SegmentKey const & other);
7438 
7442  SegmentKey(SegmentKey && in_that);
7443 
7447  SegmentKey & operator=(SegmentKey && in_that);
7448 
7450  explicit SegmentKey(Key const & in_that);
7451 
7453  ~SegmentKey();
7454 
7455  HPS::Type ObjectType() const {return HPS::Type::SegmentKey;};
7456 
7458  UTF8 Name() const;
7459 
7462  SegmentKey & SetName(char const * in_name);
7463 
7466  SegmentKey Down(char const * in_segment_name, bool in_create_if_not_present = false) const;
7467 
7470  SegmentKey Subsegment(char const * in_segment_name = "", bool in_create_if_not_present = true) const;
7471 
7473  void Flush(Search::Type in_type_to_remove = Search::Type::Everything, Search::Space in_search_space = Search::Space::SegmentOnly);
7474 
7476  void Flush(SearchTypeArray const & in_types_to_remove, Search::Space in_search_space = Search::Space::SegmentOnly);
7477 
7479  void Flush(size_t in_types_count, Search::Type const in_types_to_remove [], Search::Space in_search_space = Search::Space::SegmentOnly);
7480 
7481 
7482 
7484  size_t Find(Search::Type in_request, Search::Space in_search_space, SearchResults & out_results) const;
7485 
7487  size_t Find(SearchTypeArray const & in_requests, Search::Space in_search_space, SearchResults & out_results) const;
7488 
7490  size_t Find(size_t in_types_count, Search::Type const in_requests [], Search::Space in_search_space, SearchResults & out_results) const;
7491 
7492 
7494  size_t Find(SearchOptionsKit const & in_options, SearchResults & out_results) const;
7495 
7497  size_t Find(SearchOptionsKit const & in_options) const;
7498 
7499 
7502  IncludeKey IncludeSegment(SegmentKey const & in_seg);
7503 
7507  IncludeKey IncludeSegment(SegmentKey const & in_seg, Condition const & in_condition);
7508 
7509 
7515  ReferenceKey ReferenceGeometry(Key const & in_key);
7516 
7524  ReferenceKey ReferenceGeometry(Key const & in_key, Condition const & in_condition);
7525 
7526 
7528  size_t ShowSubsegments() const;
7529 
7531  size_t ShowSubsegments(SegmentKeyArray & out_children) const;
7532 
7536  size_t ShowReferrers(SegmentKeyArray & out_segments) const;
7537 
7541  size_t ShowReferrers(ReferenceKeyArray & out_references) const;
7542 
7546  size_t ShowStylers(SegmentKeyArray & out_segments) const;
7547 
7551  size_t ShowStylers(StyleKeyArray & out_styles) const;
7552 
7556  size_t ShowIncluders(SegmentKeyArray & out_segments) const;
7557 
7561  size_t ShowIncluders(IncludeKeyArray & out_includes) const;
7562 
7563 
7564 
7566  StyleControl GetStyleControl();
7567 
7569  StyleControl const GetStyleControl() const;
7570 
7571 
7573  PortfolioControl GetPortfolioControl();
7574 
7576  PortfolioControl const GetPortfolioControl() const;
7577 
7578 
7580  SegmentKey & SetCondition(char const * in_condition);
7581 
7583  SegmentKey & SetConditions(UTF8Array const & in_conditions);
7584 
7586  SegmentKey & SetConditions(size_t in_count, UTF8 const in_conditions []);
7587 
7589  SegmentKey & UnsetConditions();
7590 
7592  bool ShowConditions(UTF8Array & out_conditions) const;
7593 
7595  ConditionControl GetConditionControl();
7596 
7598  ConditionControl const GetConditionControl() const;
7599 
7600 
7602  SegmentKey & SetMaterialPalette(char const * in_name);
7603 
7605  SegmentKey & UnsetMaterialPalette();
7606 
7608  bool ShowMaterialPalette(UTF8 & out_name) const;
7609 
7610 
7617  SegmentKey & SetPriority(int in_priority);
7618 
7621  SegmentKey & UnsetPriority();
7622 
7626  bool ShowPriority(int & out_priority) const;
7627 
7632  SegmentKey & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
7633 
7639  SegmentKey & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
7640 
7645  SegmentKey & SetUserData(intptr_t in_index, ByteArray const & in_data);
7646 
7650  SegmentKey & UnsetUserData(intptr_t in_index);
7651 
7656  SegmentKey & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
7657 
7661  SegmentKey & UnsetUserData(HPS::IntPtrTArray const & in_indices);
7662 
7665  SegmentKey & UnsetAllUserData();
7666 
7668  size_t ShowUserDataCount() const;
7669 
7674  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
7675 
7679  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
7680 
7685  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
7686 
7687 
7689  LineKey InsertLine(LineKit const & in_kit);
7690 
7692  LineKey InsertLine(size_t in_count, Point const in_pts[]);
7693 
7695  LineKey InsertLine(PointArray const & in_pts);
7696 
7698  LineKey InsertLine(Point const & pt1, Point const & pt2);
7699 
7700 
7702  CylinderKey InsertCylinder(CylinderKit const & in_kit);
7703 
7705  CylinderKey InsertCylinder(size_t in_pcount, Point const in_points[], size_t in_rcount, float const in_radii [], Cylinder::Capping in_caps = Cylinder::Capping::Both);
7706 
7708  CylinderKey InsertCylinder(PointArray const & in_points, FloatArray const & in_radii, Cylinder::Capping in_caps = Cylinder::Capping::Both);
7709 
7711  CylinderKey InsertCylinder(Point const & in_point1, Point const & in_point2, float in_radius, Cylinder::Capping in_caps = Cylinder::Capping::Both);
7712 
7713 
7718  SphereKey InsertSphere(SphereKit const & in_kit);
7719 
7727  SphereKey InsertSphere(Point const & in_center, float in_radius, Vector const & in_axis = Vector(0, 1, 0), Vector const & in_prime_meridian = Vector(1, 0, 0));
7728 
7730  CircleKey InsertCircle(CircleKit const & in_kit);
7731 
7733  CircleKey InsertCircle(Point const & in_start, Point const & in_middle, Point const & in_end);
7734 
7736  CircleKey InsertCircle(Point const & in_center, float in_radius, Vector const & in_normal);
7737 
7738 
7740  CircularArcKey InsertCircularArc(CircularArcKit const & in_kit);
7741 
7743  CircularArcKey InsertCircularArc(Point const & in_start, Point const & in_middle, Point const & in_end);
7744 
7745 
7747  CircularWedgeKey InsertCircularWedge(CircularWedgeKit const & in_kit);
7748 
7750  CircularWedgeKey InsertCircularWedge(Point const & in_start, Point const & in_middle, Point const & in_end);
7751 
7752 
7754  EllipseKey InsertEllipse(EllipseKit const & in_kit);
7755 
7757  EllipseKey InsertEllipse(Point const & in_center, Point const & in_major, Point const & in_minor);
7758 
7759 
7761  EllipticalArcKey InsertEllipticalArc(EllipticalArcKit const & in_kit);
7762 
7764  EllipticalArcKey InsertEllipticalArc(Point const & in_center, Point const & in_major, Point const & in_minor, float in_start, float in_end);
7765 
7766 
7768  PolygonKey InsertPolygon(PolygonKit const & in_kit);
7769 
7771  PolygonKey InsertPolygon(PointArray const & in_points);
7772 
7774  PolygonKey InsertPolygon(size_t in_count, Point const in_points []);
7775 
7776 
7778  ShellKey InsertShell(ShellKit const & in_kit);
7779 
7781  ShellKey InsertShell(PointArray const & in_points, IntArray const & in_facelist);
7782 
7784  ShellKey InsertShell(size_t in_point_count, Point const in_points [], size_t in_facelist_count, int const in_facelist []);
7785 
7787  ShellKey InsertShellByTristrips(PointArray const & in_points, IntArray const & in_tristrips);
7788 
7790  ShellKey InsertShellByTristrips(size_t in_point_count, Point const in_points [], size_t in_tristrips_count, int const in_tristrips []);
7791 
7793  MeshKey InsertMesh(MeshKit const & in_kit);
7794 
7796  MeshKey InsertMesh(size_t in_rows, size_t in_columns, PointArray const & in_points);
7797 
7799  MeshKey InsertMesh(size_t in_rows, size_t in_columns, size_t in_point_count, Point const in_points []);
7800 
7801 
7803  MarkerKey InsertMarker(Point const & in_position);
7804 
7806  MarkerKey InsertMarker(MarkerKit const & in_kit);
7807 
7808 
7810  DistantLightKey InsertDistantLight(Vector const & in_direction);
7811 
7813  DistantLightKey InsertDistantLight(DistantLightKit const & in_kit);
7814 
7815 
7817  CuttingSectionKey InsertCuttingSection(Plane const & in_plane);
7818 
7820  CuttingSectionKey InsertCuttingSection(CuttingSectionKit const & in_kit);
7821 
7823  CuttingSectionKey InsertCuttingSection(PlaneArray const & in_planes);
7824 
7826  CuttingSectionKey InsertCuttingSection(size_t in_planes_count, Plane const in_planes []);
7827 
7828 
7830  InfiniteLineKey InsertInfiniteLine(InfiniteLineKit const & in_kit);
7831 
7833  InfiniteLineKey InsertInfiniteLine(Point const & in_first, Point const & in_second, InfiniteLine::Type in_type);
7834 
7835 
7837  SpotlightKey InsertSpotlight(Point const & in_position, Point const & in_target);
7838 
7840  SpotlightKey InsertSpotlight(SpotlightKit const & in_kit);
7841 
7842 
7844  NURBSCurveKey InsertNURBSCurve(NURBSCurveKit const & in_kit);
7845 
7847  NURBSCurveKey InsertNURBSCurve(size_t in_degree, PointArray const & in_points, FloatArray const & in_weights, FloatArray const & in_knots, float in_start_u, float in_end_u);
7848 
7850  NURBSCurveKey InsertNURBSCurve(size_t in_degree, size_t in_pcount, Point const in_points [], float const in_weights[], size_t in_knot_count, float const in_knots[], float in_start_u, float in_end_u);
7851 
7852 
7854  NURBSSurfaceKey InsertNURBSSurface(NURBSSurfaceKit const & in_kit);
7855 
7857  NURBSSurfaceKey InsertNURBSSurface(size_t in_udegree, size_t in_vdegree, size_t in_ucount, size_t in_vcount, PointArray const & in_points, FloatArray const & in_weights, FloatArray const & in_uknots, FloatArray const & in_vknots);
7858 
7860  NURBSSurfaceKey InsertNURBSSurface(size_t in_udegree, size_t in_vdegree, size_t in_ucount, size_t in_vcount, size_t in_point_count, Point const in_points[], float const in_weights[], size_t in_uknot_count, float const in_uknots[], size_t in_vknot_count, float const in_vknots[]);
7861 
7863  NURBSSurfaceKey InsertNURBSSurface(size_t in_udegree, size_t in_vdegree, size_t in_ucount, size_t in_vcount, PointArray const & in_points, FloatArray const & in_weights, FloatArray const & in_uknots, FloatArray const & in_vknots, TrimKitArray const & in_trims);
7864 
7866  NURBSSurfaceKey InsertNURBSSurface(size_t in_udegree, size_t in_vdegree, size_t in_ucount, size_t in_vcount, size_t in_point_count, Point const in_points[], float const in_weights[], size_t in_uknot_count, float const in_uknots[], size_t in_vknot_count, float const in_vknots[], size_t in_trim_count, TrimKit const in_trims[]);
7867 
7868 
7870  TextKey InsertText(TextKit const & in_kit);
7871 
7877  TextKey InsertText(Point const & in_position, char const * in_text);
7878 
7879 
7880 
7882  GridKey InsertGrid(GridKit const & in_kit);
7883 
7885  GridKey InsertGrid(Point const & in_origin, Point const & in_first_point = Point(1, 0, 0), Point const & in_second_point = Point(0, 1, 0), int in_first_count = 0, int in_second_count = 0, Grid::Type in_type = Grid::Type::Quadrilateral);
7886 
7887 
7888 
7896  LineKey InsertLineFromGeometry(CircleKey const & in_circle, float in_deviation = -1.0f);
7897 
7905  LineKey InsertLineFromGeometry(CircularArcKey const & in_circular_arc, float in_deviation = -1.0f);
7906 
7914  LineKey InsertLineFromGeometry(CircularWedgeKey const & in_circular_wedge, float in_deviation = -1.0f);
7915 
7923  LineKey InsertLineFromGeometry(EllipseKey const & in_ellipse, float in_deviation = -1.0f);
7924 
7932  LineKey InsertLineFromGeometry(EllipticalArcKey const & in_elliptical_arc, float in_deviation = -1.0f);
7933 
7941  LineKey InsertLineFromGeometry(NURBSCurveKey const & in_nurbs_curve, float in_deviation = -1.0f);
7942 
7947  ShellKey InsertShellFromGeometry(SphereKey const & in_sphere);
7948 
7953  ShellKey InsertShellFromGeometry(CylinderKey const & in_cylinder);
7954 
7959  ShellKey InsertShellFromGeometry(NURBSSurfaceKey const & in_nurbs_surface);
7960 
7965  ShellKey InsertShellFromGeometry(MeshKey const & in_mesh);
7966 
7971  ShellKey InsertShellFromGeometry(PolygonKey const & in_polygon);
7972 
7977  ShellKey InsertShellFromGeometry(TextKey const & in_text);
7978 
7979 
7981  SegmentKey & SetAttributeLocks(AttributeLockKit const & in_kit);
7982 
7984  SegmentKey & UnsetAttributeLocks();
7985 
7989  bool ShowAttributeLocks(AttributeLockKit & out_kit) const;
7990 
7992  AttributeLockControl GetAttributeLockControl();
7993 
7995  AttributeLockControl const GetAttributeLockControl() const;
7996 
7997 
7999  SegmentKey & SetBoundings(BoundingKit const & in_kit);
8000 
8002  SegmentKey & UnsetBoundings();
8003 
8007  bool ShowBoundings(BoundingKit & out_kit) const;
8008 
8010  BoundingControl GetBoundingControl();
8011 
8013  BoundingControl const GetBoundingControl() const;
8014 
8015 
8017  SegmentKey & SetCamera(CameraKit const & in_kit);
8018 
8020  SegmentKey & UnsetCamera();
8021 
8023  bool ShowCamera(CameraKit & out_kit) const;
8024 
8026  CameraControl GetCameraControl();
8027 
8029  CameraControl const GetCameraControl() const;
8030 
8032  SegmentKey & SetColorInterpolation(ColorInterpolationKit const & in_kit);
8033 
8035  SegmentKey & UnsetColorInterpolation();
8036 
8038  bool ShowColorInterpolation(ColorInterpolationKit & out_kit) const;
8039 
8041  ColorInterpolationControl GetColorInterpolationControl();
8042 
8044  ColorInterpolationControl const GetColorInterpolationControl() const;
8045 
8046 
8048  SegmentKey & SetContourLine(ContourLineKit const & in_kit);
8049 
8051  SegmentKey & UnsetContourLine();
8052 
8054  bool ShowContourLine(ContourLineKit & out_kit) const;
8055 
8057  ContourLineControl GetContourLineControl();
8058 
8060  ContourLineControl const GetContourLineControl() const;
8061 
8062 
8064  SegmentKey & SetCulling(CullingKit const & in_kit);
8065 
8067  SegmentKey & UnsetCulling();
8068 
8072  bool ShowCulling(CullingKit & out_kit) const;
8073 
8075  CullingControl GetCullingControl();
8076 
8078  CullingControl const GetCullingControl() const;
8079 
8080 
8082  SegmentKey & SetCurveAttributes(CurveAttributeKit const & in_kit);
8083 
8085  SegmentKey & UnsetCurveAttributes();
8086 
8088  bool ShowCurveAttributes(CurveAttributeKit & out_kit) const;
8089 
8091  CurveAttributeControl GetCurveAttributeControl();
8092 
8094  CurveAttributeControl const GetCurveAttributeControl() const;
8095 
8096 
8098  SegmentKey & SetCuttingSectionAttributes(CuttingSectionAttributeKit const & in_kit);
8099 
8101  SegmentKey & UnsetCuttingSectionAttributes();
8102 
8104  bool ShowCuttingSectionAttributes(CuttingSectionAttributeKit & out_kit) const;
8105 
8107  CuttingSectionAttributeControl GetCuttingSectionAttributeControl();
8108 
8110  CuttingSectionAttributeControl const GetCuttingSectionAttributeControl() const;
8111 
8112 
8114  SegmentKey & SetCylinderAttributes(CylinderAttributeKit const & in_kit);
8115 
8117  SegmentKey & UnsetCylinderAttributes();
8118 
8120  bool ShowCylinderAttributes(CylinderAttributeKit & out_kit) const;
8121 
8123  CylinderAttributeControl GetCylinderAttributeControl();
8124 
8126  CylinderAttributeControl const GetCylinderAttributeControl() const;
8127 
8128 
8130  SegmentKey & SetDrawingAttribute(DrawingAttributeKit const & in_kit);
8131 
8133  SegmentKey & UnsetDrawingAttribute();
8134 
8136  bool ShowDrawingAttribute(DrawingAttributeKit & out_kit) const;
8137 
8139  DrawingAttributeControl GetDrawingAttributeControl();
8140 
8142  DrawingAttributeControl const GetDrawingAttributeControl() const;
8143 
8144 
8146  SegmentKey & SetEdgeAttributes(EdgeAttributeKit const & in_kit);
8147 
8149  SegmentKey & UnsetEdgeAttributes();
8150 
8152  bool ShowEdgeAttributes(EdgeAttributeKit & out_kit) const;
8153 
8155  EdgeAttributeControl GetEdgeAttributeControl();
8156 
8158  EdgeAttributeControl const GetEdgeAttributeControl() const;
8159 
8160 
8162  SegmentKey & SetHiddenLineAttribute(HiddenLineAttributeKit const & in_kit);
8163 
8165  SegmentKey & UnsetHiddenLineAttribute();
8166 
8168  bool ShowHiddenLineAttribute(HiddenLineAttributeKit & out_kit) const;
8169 
8171  HiddenLineAttributeControl GetHiddenLineAttributeControl();
8172 
8174  HiddenLineAttributeControl const GetHiddenLineAttributeControl() const;
8175 
8176 
8178  SegmentKey & SetLightingAttributes(LightingAttributeKit const & in_kit);
8179 
8181  SegmentKey & UnsetLightingAttributes();
8182 
8184  bool ShowLightingAttributes(LightingAttributeKit & out_kit) const;
8185 
8187  LightingAttributeControl GetLightingAttributeControl();
8188 
8190  LightingAttributeControl const GetLightingAttributeControl() const;
8191 
8192 
8194  SegmentKey & SetLineAttributes(LineAttributeKit const & in_kit);
8195 
8197  SegmentKey & UnsetLineAttributes();
8198 
8200  bool ShowLineAttributes(LineAttributeKit & out_kit) const;
8201 
8203  LineAttributeControl GetLineAttributeControl();
8204 
8206  LineAttributeControl const GetLineAttributeControl() const;
8207 
8208 
8210  SegmentKey & SetMaterialMapping(MaterialMappingKit const & in_kit);
8211 
8213  SegmentKey & UnsetMaterialMapping();
8214 
8216  bool ShowMaterialMapping(MaterialMappingKit & out_kit) const;
8217 
8219  MaterialMappingControl GetMaterialMappingControl();
8220 
8222  MaterialMappingControl const GetMaterialMappingControl() const;
8223 
8224 
8226  SegmentKey & SetMarkerAttributes(MarkerAttributeKit const & in_kit);
8227 
8229  SegmentKey & UnsetMarkerAttributes();
8230 
8232  bool ShowMarkerAttributes(MarkerAttributeKit & out_kit) const;
8233 
8235  MarkerAttributeControl GetMarkerAttributeControl();
8236 
8238  MarkerAttributeControl const GetMarkerAttributeControl() const;
8239 
8240 
8242  SegmentKey & SetModellingMatrix(MatrixKit const & in_kit);
8243 
8245  SegmentKey & UnsetModellingMatrix();
8246 
8248  bool ShowModellingMatrix(MatrixKit & out_kit) const;
8249 
8251  ModellingMatrixControl GetModellingMatrixControl();
8252 
8254  ModellingMatrixControl const GetModellingMatrixControl() const;
8255 
8256 
8258  SegmentKey & SetNURBSSurfaceAttributes(NURBSSurfaceAttributeKit const & in_kit);
8259 
8261  SegmentKey & UnsetNURBSSurfaceAttributes();
8262 
8264  bool ShowNURBSSurfaceAttributes(NURBSSurfaceAttributeKit & out_kit) const;
8265 
8267  NURBSSurfaceAttributeControl GetNURBSSurfaceAttributeControl();
8268 
8270  NURBSSurfaceAttributeControl const GetNURBSSurfaceAttributeControl() const;
8271 
8272 
8274  SegmentKey & SetPerformance(PerformanceKit const & in_kit);
8275 
8277  SegmentKey & UnsetPerformance();
8278 
8280  bool ShowPerformance(PerformanceKit & out_kit) const;
8281 
8283  PerformanceControl GetPerformanceControl();
8284 
8286  PerformanceControl const GetPerformanceControl() const;
8287 
8288 
8290  SegmentKey & SetSelectability(SelectabilityKit const & in_kit);
8291 
8293  SegmentKey & UnsetSelectability();
8294 
8298  bool ShowSelectability(SelectabilityKit & out_kit) const;
8299 
8301  SelectabilityControl GetSelectabilityControl();
8302 
8304  SelectabilityControl const GetSelectabilityControl() const;
8305 
8306 
8308  SegmentKey & SetSphereAttributes(SphereAttributeKit const & in_kit);
8309 
8311  SegmentKey & UnsetSphereAttributes();
8312 
8316  bool ShowSphereAttributes(SphereAttributeKit & out_kit) const;
8317 
8319  SphereAttributeControl GetSphereAttributeControl();
8320 
8322  SphereAttributeControl const GetSphereAttributeControl() const;
8323 
8324 
8326  SegmentKey & SetSubwindow(SubwindowKit const & in_kit);
8327 
8329  SegmentKey & UnsetSubwindow();
8330 
8334  bool ShowSubwindow(SubwindowKit & out_kit) const;
8335 
8337  SubwindowControl GetSubwindowControl();
8338 
8340  SubwindowControl const GetSubwindowControl() const;
8341 
8342 
8344  SegmentKey & SetTextAttributes(TextAttributeKit const & in_kit);
8345 
8347  SegmentKey & UnsetTextAttributes();
8348 
8350  bool ShowTextAttributes(TextAttributeKit & out_kit) const;
8351 
8353  TextAttributeControl GetTextAttributeControl();
8354 
8356  TextAttributeControl const GetTextAttributeControl() const;
8357 
8358 
8360  SegmentKey & SetTextureMatrix(MatrixKit const & in_kit);
8361 
8363  SegmentKey & UnsetTextureMatrix();
8364 
8368  bool ShowTextureMatrix(MatrixKit & out_kit) const;
8369 
8371  TextureMatrixControl GetTextureMatrixControl();
8372 
8374  TextureMatrixControl const GetTextureMatrixControl() const;
8375 
8377  SegmentKey & SetTransformMask(TransformMaskKit const & in_kit);
8378 
8380  SegmentKey & UnsetTransformMask();
8381 
8385  bool ShowTransformMask(TransformMaskKit & out_kit) const;
8386 
8388  TransformMaskControl GetTransformMaskControl();
8389 
8391  TransformMaskControl const GetTransformMaskControl() const;
8392 
8393 
8395  SegmentKey & SetTransparency(TransparencyKit const & in_kit);
8396 
8398  SegmentKey & UnsetTransparency();
8399 
8403  bool ShowTransparency(TransparencyKit & out_kit) const;
8404 
8406  TransparencyControl GetTransparencyControl();
8407 
8409  TransparencyControl const GetTransparencyControl() const;
8410 
8411 
8413  SegmentKey & SetVisibility(VisibilityKit const & in_kit);
8414 
8416  SegmentKey & UnsetVisibility();
8417 
8421  bool ShowVisibility(VisibilityKit & out_kit) const;
8422 
8424  VisibilityControl GetVisibilityControl();
8425 
8427  VisibilityControl const GetVisibilityControl() const;
8428 
8429 
8431  SegmentKey & SetVisualEffects(VisualEffectsKit const & in_kit);
8432 
8434  SegmentKey & UnsetVisualEffects();
8435 
8439  bool ShowVisualEffects(VisualEffectsKit & out_kit) const;
8440 
8442  VisualEffectsControl GetVisualEffectsControl();
8443 
8445  VisualEffectsControl const GetVisualEffectsControl() const;
8446 
8447  void Optimize(SegmentOptimizationOptionsKit const & in_kit);
8448 };
8449 
8450 
8453 {
8454 public:
8455 
8458 
8462 
8466 
8467  virtual ~SegmentOptimizationOptionsKit();
8468 
8469  HPS::Type ObjectType() const { return HPS::Type::SegmentOptimizationOptionsKit; }
8470 
8473  void Consume(SegmentOptimizationOptionsKit & in_kit);
8474 
8477  void Set(SegmentOptimizationOptionsKit const & in_kit);
8478 
8481  void Show(SegmentOptimizationOptionsKit & out_kit) const;
8482 
8487 
8492 
8495  bool Empty() const;
8496 
8500  bool Equals(SegmentOptimizationOptionsKit const & in_kit) const;
8501 
8505  bool operator==(SegmentOptimizationOptionsKit const & in_kit) const;
8506 
8510  bool operator!=(SegmentOptimizationOptionsKit const & in_kit) const;
8511 
8515  SegmentOptimizationOptionsKit & SetUserData(HPS::SegmentOptimizationOptions::UserData in_user_data);
8516 
8520  SegmentOptimizationOptionsKit & SetMatrix(HPS::SegmentOptimizationOptions::Matrix in_matrix);
8521 
8525  SegmentOptimizationOptionsKit & SetExpansion(HPS::SegmentOptimizationOptions::Expansion in_expansion);
8526 
8530  SegmentOptimizationOptionsKit & SetScope(HPS::SegmentOptimizationOptions::Scope in_scope);
8531 
8535  SegmentOptimizationOptionsKit & SetReorganization(HPS::SegmentOptimizationOptions::Reorganization in_reorganization);
8536 
8540  SegmentOptimizationOptionsKit & SetShellInstancing(bool in_shell_instancing);
8541 
8545  SegmentOptimizationOptionsKit & SetShellMerging(bool in_shell_merging);
8546 
8550  SegmentOptimizationOptionsKit & SetAttributeDelocalization(bool in_attribute_delocalization);
8551 
8553  SegmentOptimizationOptionsKit & UnsetUserData();
8554 
8556  SegmentOptimizationOptionsKit & UnsetMatrix();
8557 
8559  SegmentOptimizationOptionsKit & UnsetExpansion();
8560 
8562  SegmentOptimizationOptionsKit & UnsetScope();
8563 
8565  SegmentOptimizationOptionsKit & UnsetReorganization();
8566 
8568  SegmentOptimizationOptionsKit & UnsetShellInstancing();
8569 
8571  SegmentOptimizationOptionsKit & UnsetShellMerging();
8572 
8574  SegmentOptimizationOptionsKit & UnsetAttributeDelocalization();
8575 
8578  SegmentOptimizationOptionsKit & UnsetEverything();
8579 
8580  bool ShowUserData(HPS::SegmentOptimizationOptions::UserData & out_user_data) const;
8581 
8582  bool ShowMatrix(HPS::SegmentOptimizationOptions::Matrix & out_matrix) const;
8583 
8584  bool ShowExpansion(HPS::SegmentOptimizationOptions::Expansion & out_expansion) const;
8585 
8586  bool ShowScope(HPS::SegmentOptimizationOptions::Scope & out_scope) const;
8587 
8588  bool ShowReorganization(HPS::SegmentOptimizationOptions::Reorganization & out_reorganization) const;
8589 
8590  bool ShowShellInstancing(bool & out_shell_instancing) const;
8591 
8592  bool ShowShellMerging(bool & out_shell_merging) const;
8593 
8594  bool ShowAttributeDelocalization(bool & out_attribute_delocalization) const;
8595 };
8596 
8597 
8599 class HPS_API Coordinate
8600 {
8601 public:
8602 
8606  enum class Space
8607  {
8608  Object,
8609  World,
8610  Camera,
8611  Normalized,
8612  ScreenRange,
8613  InnerWindow,
8614  InnerPixel,
8615  Window,
8616  Pixel,
8617  };
8618 
8619 private:
8620  Coordinate();
8621 };
8622 
8623 
8624 
8625 
8628 class HPS_API UpdateNotifier : public Object
8629 {
8630 public:
8631 
8632  UpdateNotifier();
8633 
8634  UpdateNotifier(UpdateNotifier const & in_that);
8635 
8639  UpdateNotifier(UpdateNotifier && in_that);
8640 
8644  UpdateNotifier & operator=(UpdateNotifier && in_that);
8645 
8646  virtual ~UpdateNotifier();
8647 
8648  HPS::Type ObjectType() const {return HPS::Type::UpdateNotifier;};
8649 
8653  UpdateNotifier & operator=(UpdateNotifier const & in_that);
8654 
8657  void Assign(UpdateNotifier const & in_that);
8658 
8659  void Wait() const;
8660 
8661  Window::UpdateStatus Status() const;
8662 
8663 };
8664 
8667 class HPS_API DriverEvent
8668 {
8669 public:
8670 
8671  virtual ~DriverEvent();
8672 
8674  intptr_t GetClassID() const;
8675 
8676 protected:
8677 
8678  DriverEvent(OpaqueHandle in_nr) : nr(in_nr)
8679  {
8680 
8681  }
8682 
8683  OpaqueHandle nr;
8684 };
8685 
8688 class HPS_API FinishPictureEvent : public DriverEvent
8689 {
8690 public:
8691  FinishPictureEvent(OpaqueHandle in_nr = 0);
8692  virtual ~FinishPictureEvent();
8693 };
8694 
8696 class HPS_API DrawWindowEvent : public DriverEvent
8697 {
8698 public:
8699  DrawWindowEvent(OpaqueHandle in_nr = 0);
8700  virtual ~DrawWindowEvent();
8701 
8703  Rectangle Extent;
8704 
8709  void DrawTexturedBackground(OpaqueHandle in_texture, MatrixKit const & in_matrix, Rectangle const & in_extent) const;
8710 
8711 private:
8712 
8713  mutable HPS::FloatArray matrix_elements;
8714 };
8715 
8717 class HPS_API DriverEventHandler : public Object
8718 {
8719 public:
8720 
8721  HPS::Type ObjectType() const OVERRIDE { return HPS::Type::DriverEventHandler; };
8722 
8724 
8725  DriverEventHandler(DriverEventHandler const & that);
8726 
8727  virtual ~DriverEventHandler();
8728 
8732  virtual void Handle(DriverEvent const * in_event)
8733  {
8734  HPS_UNREFERENCED(in_event);
8735  }
8736 };
8737 
8738 
8739 
8740 
8744 class HPS_API WindowKey : public SegmentKey
8745 {
8746 public:
8747 
8749  WindowKey();
8750 
8752  WindowKey(WindowKey const & in_window);
8753 
8755  WindowKey & operator=(WindowKey const & other);
8756 
8760  WindowKey(WindowKey && in_that);
8761 
8765  WindowKey & operator=(WindowKey && in_that);
8766 
8768  WindowKey(Key const & in_key);
8769 
8771  ~WindowKey();
8772 
8773  HPS::Type ObjectType() const {return HPS::Type::WindowKey;};
8774 
8776  bool ConvertCoordinate(Coordinate::Space in_space, Point const & in_point, Coordinate::Space in_output_space, Point & out_point) const;
8777 
8782  size_t FindFonts(FontSearchResults & out_results) const;
8783 
8785  WindowKey & SetPostProcessEffects(PostProcessEffectsKit const & in_kit);
8786 
8788  bool ShowPostProcessEffects(PostProcessEffectsKit & out_kit) const;
8789 
8791  PostProcessEffectsControl GetPostProcessEffectsControl();
8792 
8794  PostProcessEffectsControl const GetPostProcessEffectsControl() const;
8795 
8796 
8798  WindowKey & SetDebugging(DebuggingKit const & in_kit);
8799 
8803  WindowKey & SetDriverEventHandler(DriverEventHandler const & in_handler, intptr_t in_type);
8804 
8807  WindowKey & UnsetDriverEventHandler(intptr_t in_type);
8808 
8812  bool ShowDebugging(DebuggingKit & out_kit) const;
8813 
8815  DebuggingControl GetDebuggingControl();
8816 
8818  DebuggingControl const GetDebuggingControl() const;
8819 
8821  WindowInfoControl const GetWindowInfoControl() const;
8822 
8823  bool ShowWindowInfo(WindowInfoKit & out_kit) const;
8824 
8826  WindowKey & SetSelectionOptions(SelectionOptionsKit const & in_kit);
8827 
8829  bool ShowSelectionOptions(SelectionOptionsKit & out_kit) const;
8830 
8832  WindowKey & SetUpdateOptions(HPS::UpdateOptionsKit const & in_kit);
8833 
8835  bool ShowUpdateOptions(HPS::UpdateOptionsKit & out_kit) const;
8836 
8837 
8839  SelectionOptionsControl GetSelectionOptionsControl();
8840 
8842  SelectionOptionsControl const GetSelectionOptionsControl() const;
8843 
8844 
8846  SelectionControl GetSelectionControl();
8847 
8849  SelectionControl const GetSelectionControl() const;
8850 
8852  HighlightControl GetHighlightControl();
8853 
8855  HighlightControl const GetHighlightControl() const;
8856 
8858  UpdateOptionsControl GetUpdateOptionsControl();
8859 
8861  UpdateOptionsControl const GetUpdateOptionsControl() const;
8862 
8864  void Update();
8865 
8870  void Update(UpdateOptionsKit const & in_kit);
8871 
8886  void Update(Window::UpdateControl in_control, Time in_time_limit=-1);
8887 
8891  UpdateNotifier UpdateWithNotifier();
8892 
8896  UpdateNotifier UpdateWithNotifier(HPS::UpdateOptionsKit const & in_kit);
8897 
8903  UpdateNotifier UpdateWithNotifier(Window::UpdateControl in_control, Time in_time_limit=-1);
8904 
8906  EventDispatcher & GetEventDispatcher();
8907 
8909  EventDispatcher const & GetEventDispatcher() const;
8910 
8914  bool ShowSnapshot(ImageKit & out_kit) const;
8915 
8916 private:
8917 
8919  SegmentKey & UnsetAttributeLocks();
8920  SegmentKey & UnsetCamera();
8921  SegmentKey & UnsetColorInterpolation();
8922  SegmentKey & UnsetContourLine();
8923  SegmentKey & UnsetCulling();
8924  SegmentKey & UnsetCurveAttributes();
8925  SegmentKey & UnsetCuttingSectionAttributes();
8926  SegmentKey & UnsetCylinderAttributes();
8927  SegmentKey & UnsetDrawingAttribute();
8928  SegmentKey & UnsetEdgeAttributes();
8929  SegmentKey & UnsetHiddenLineAttribute();
8930  SegmentKey & UnsetLightingAttributes();
8931  SegmentKey & UnsetLineAttributes();
8932  SegmentKey & UnsetMaterialMapping();
8933  SegmentKey & UnsetMarkerAttributes();
8934  SegmentKey & UnsetModellingMatrix();
8935  SegmentKey & UnsetNURBSSurfaceAttributes();
8936  SegmentKey & UnsetPerformance();
8937  SegmentKey & UnsetSelectability();
8938  SegmentKey & UnsetSphereAttributes();
8939  SegmentKey & UnsetSubwindow();
8940  SegmentKey & UnsetTextAttributes();
8941  SegmentKey & UnsetTextureMatrix();
8942  SegmentKey & UnsetTransformMask();
8943  SegmentKey & UnsetTransparency();
8944  SegmentKey & UnsetVisibility();
8945  SegmentKey & UnsetVisualEffects();
8946 
8948  void MoveTo(SegmentKey const & in_new_owner);
8949 
8951  Key CopyTo(SegmentKey const & in_destination) const;
8952 };
8953 
8954 
8955 
8958 class HPS_API KeyPath : public Object
8959 {
8960 public:
8961 
8963  KeyPath();
8964 
8967  KeyPath(KeyArray const & in_path);
8968 
8972  KeyPath(size_t in_path_count, Key const in_path []);
8973 
8975  KeyPath(KeyPath const & in_that);
8976 
8980  KeyPath(KeyPath && in_that);
8981 
8985  KeyPath & operator=(KeyPath && in_that);
8986 
8988  virtual ~KeyPath();
8989 
8990  HPS::Type ObjectType() const { return HPS::Type::KeyPath; }
8991 
8995  KeyPath & operator+=(Key const & in_key);
8996 
9000  KeyPath & operator+=(KeyPath const & in_key_path);
9001 
9005  KeyPath & operator+=(KeyArray const & in_key_array);
9006 
9010  KeyPath & Append(Key const & in_key);
9011 
9015  KeyPath & Append(KeyPath const & in_key_path);
9016 
9020  KeyPath & Append(KeyArray const & in_key_array);
9021 
9025  KeyPath & operator=(KeyPath const & in_that);
9026 
9030  KeyPath & operator=(KeyArray const & in_path);
9031 
9034  void Set(KeyPath const & in_that);
9035 
9039  bool Equals(KeyPath const & in_that) const;
9040 
9044  bool operator!= (KeyPath const & in_that) const;
9045 
9049  bool operator== (KeyPath const & in_that) const;
9050 
9051 
9055  KeyPath & SetKeys(KeyArray const & in_keys);
9056 
9061  KeyPath & SetKeys(size_t in_key_count, Key const in_keys []);
9062 
9063 
9066  KeyPath & UnsetKeys();
9067 
9068 
9071  bool ShowKeys(KeyArray & out_keys) const;
9072 
9073 
9080  bool ConvertCoordinate(Coordinate::Space in_space, Point const & in_point, Coordinate::Space in_output_space, Point & out_point) const;
9081 
9088  bool ConvertCoordinate(Coordinate::Space in_space, PointArray const & in_points, Coordinate::Space in_output_space, PointArray & out_points) const;
9089 
9095  bool ComputeTextExtent(char const * in_text, float & out_xfrac, float & out_yfrac) const;
9096 
9097 
9103  bool ComputeTransform(Coordinate::Space in_space, Coordinate::Space in_output_space, HPS::MatrixKit & out_matrix) const;
9104 
9105 
9108  bool ShowNetVisibility(VisibilityKit & out_kit) const;
9109 
9112  bool ShowNetBounding(BoundingKit & out_kit) const;
9113 
9116  bool ShowNetCamera(CameraKit & out_kit) const;
9117 
9120  bool ShowNetColorInterpolation(ColorInterpolationKit & out_kit) const;
9121 
9124  bool ShowNetContourLine(ContourLineKit & out_kit) const;
9125 
9128  bool ShowNetPerformance(PerformanceKit & out_kit) const;
9129 
9132  bool ShowNetHiddenLineAttribute(HiddenLineAttributeKit & out_kit) const;
9133 
9136  bool ShowNetDrawingAttribute(DrawingAttributeKit & out_kit) const;
9137 
9140  bool ShowNetSelectability(SelectabilityKit & out_kit) const;
9141 
9144  bool ShowNetMarkerAttributes(MarkerAttributeKit & out_kit) const;
9145 
9148  bool ShowNetSphereAttributes(SphereAttributeKit & out_kit) const;
9149 
9152  bool ShowNetLightingAttributes(LightingAttributeKit & out_kit) const;
9153 
9156  bool ShowNetCylinderAttributes(CylinderAttributeKit & out_kit) const;
9157 
9160  bool ShowNetCuttingSectionAttributes(CuttingSectionAttributeKit & out_kit) const;
9161 
9164  bool ShowNetTextAttributes(TextAttributeKit & out_kit) const;
9165 
9168  bool ShowNetLineAttributes(LineAttributeKit & out_kit) const;
9169 
9172  bool ShowNetEdgeAttributes(EdgeAttributeKit & out_kit) const;
9173 
9176  bool ShowNetCurveAttributes(CurveAttributeKit & out_kit) const;
9177 
9180  bool ShowNetModellingMatrix(MatrixKit & out_kit) const;
9181 
9184  bool ShowNetTextureMatrix(MatrixKit & out_kit) const;
9185 
9188  bool ShowNetCulling(CullingKit & out_kit) const;
9189 
9192  bool ShowNetTransparency(TransparencyKit & out_kit) const;
9193 
9196  bool ShowNetTransformMask(TransformMaskKit & out_kit) const;
9197 
9200  bool ShowNetMaterialMapping(MaterialMappingKit & out_kit) const;
9201 
9204  bool ShowNetNURBSSurfaceAttributes(NURBSSurfaceAttributeKit & out_kit) const;
9205 
9208  bool ShowNetVisualEffects(VisualEffectsKit & out_kit) const;
9209 
9212  bool ShowNetSubwindow(SubwindowKit & out_kit) const;
9213 
9216  bool ShowNetAttributeLocks(AttributeLockKit & out_kit) const;
9217 
9220  bool ShowNetConditions(UTF8Array & out_conditions) const;
9221 
9227  size_t GatherCutGeometry(SegmentKey const & in_destination, CutGeometryGatheringOptionsKit const & in_options) const;
9228 
9231  bool ShowNetMaterialPalette(UTF8 & out_name) const;
9232 
9237  bool ShowEffectiveMaterialPaletteDefinition(char const * in_name, MaterialPaletteDefinition & out_def) const;
9238 
9243  bool ShowEffectiveGlyphDefinition(char const * in_name, GlyphDefinition & out_def) const;
9244 
9249  bool ShowEffectiveLinePatternDefinition(char const * in_name, LinePatternDefinition & out_def) const;
9250 
9255  bool ShowEffectiveShaderDefinition(char const * in_name, ShaderDefinition & out_def) const;
9256 
9261  bool ShowEffectiveTextureDefinition(char const * in_name, TextureDefinition & out_def) const;
9262 
9267  bool ShowEffectiveImageDefinition(char const * in_name, ImageDefinition & out_def) const;
9268 };
9269 
9270 
9275 inline KeyPath operator+(Key const & in_lhs, Key const & in_rhs)
9276 {
9277  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9278 }
9279 
9284 inline KeyPath operator+(Key const & in_lhs, KeyArray const & in_rhs)
9285 {
9286  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9287 }
9288 
9293 inline KeyPath operator+(Key const & in_lhs, KeyPath const & in_rhs)
9294 {
9295  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9296 }
9297 
9302 inline KeyPath operator+(KeyArray const & in_lhs, Key const & in_rhs)
9303 {
9304  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9305 }
9306 
9311 inline KeyPath operator+(KeyArray const & in_lhs, KeyArray const & in_rhs)
9312 {
9313  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9314 }
9315 
9320 inline KeyPath operator+(KeyArray const & in_lhs, KeyPath const & in_rhs)
9321 {
9322  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9323 }
9324 
9329 inline KeyPath operator+(KeyPath const & in_lhs, Key const & in_rhs)
9330 {
9331  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9332 }
9333 
9338 inline KeyPath operator+(KeyPath const & in_lhs, KeyArray const & in_rhs)
9339 {
9340  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9341 }
9342 
9347 inline KeyPath operator+(KeyPath const & in_lhs, KeyPath const & in_rhs)
9348 {
9349  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9350 }
9351 
9352 
9356 
9358 class HPS_API BoundingKit : public Object
9359 {
9360 public:
9361 
9363  BoundingKit();
9364 
9367  BoundingKit(BoundingKit const & in_kit);
9368 
9372  BoundingKit(BoundingKit && in_that);
9373 
9377  BoundingKit & operator=(BoundingKit && in_that);
9378 
9380  virtual ~BoundingKit();
9381 
9382  HPS::Type ObjectType() const {return HPS::Type::BoundingKit;};
9383 
9387  static BoundingKit GetDefault();
9388 
9391  void Set(BoundingKit const & in_kit);
9392 
9395  void Show(BoundingKit & out_kit) const;
9396 
9400  BoundingKit & operator=(BoundingKit const & in_kit);
9401 
9404  bool Empty() const;
9405 
9409  bool Equals(BoundingKit const & in_kit) const;
9410 
9414  bool operator==(BoundingKit const & in_kit) const;
9415 
9419  bool operator!=(BoundingKit const & in_kit) const;
9420 
9421 
9425  BoundingKit & SetVolume(SimpleSphere const & in_sphere);
9426 
9430  BoundingKit & SetVolume(SimpleCuboid const & in_cuboid);
9431 
9435  BoundingKit & SetExclusion(bool in_exclude);
9436 
9437 
9440  BoundingKit & UnsetVolume();
9441 
9444  BoundingKit & UnsetExclusion();
9445 
9448  BoundingKit & UnsetEverything();
9449 
9450 
9455  bool ShowVolume(SimpleSphere & out_sphere, SimpleCuboid & out_cuboid) const;
9456 
9460  bool ShowExclusion(bool & out_exclusion) const;
9461 
9462 };
9463 
9464 
9467 class HPS_API BoundingControl : public Control
9468 {
9469 public:
9470 
9472  explicit BoundingControl(SegmentKey & in_seg);
9473 
9475  BoundingControl(BoundingControl const & in_that);
9476 
9480  BoundingControl(BoundingControl && in_that);
9481 
9485  BoundingControl & operator=(BoundingControl && in_that);
9486 
9488  ~BoundingControl();
9489 
9490  HPS::Type ObjectType() const {return HPS::Type::BoundingControl;};
9491 
9495  BoundingControl & operator=(BoundingControl const & in_that);
9496 
9501  BoundingControl & SetVolume(SimpleSphere const & in_sphere, SimpleCuboid const & in_cuboid);
9502 
9506  BoundingControl & SetVolume(SimpleSphere const & in_sphere);
9507 
9511  BoundingControl & SetVolume(SimpleCuboid const & in_cuboid);
9512 
9516  BoundingControl & SetExclusion(bool in_exclusion);
9517 
9518 
9521  BoundingControl & UnsetVolume();
9522 
9525  BoundingControl & UnsetExclusion();
9526 
9529  BoundingControl & UnsetEverything();
9530 
9531 
9536  bool ShowVolume(SimpleSphere & out_sphere, SimpleCuboid & out_cuboid) const;
9537 
9541  bool ShowExclusion(bool & out_exclusion) const;
9542 
9543 private:
9545  BoundingControl();
9546 };
9547 
9548 
9550 class HPS_API VisibilityKit : public Object
9551 {
9552 public:
9553 
9555  VisibilityKit();
9556 
9559  VisibilityKit(VisibilityKit const & in_kit);
9560 
9564  VisibilityKit(VisibilityKit && in_that);
9565 
9569  VisibilityKit & operator=(VisibilityKit && in_that);
9570 
9572  virtual ~VisibilityKit();
9573 
9574  HPS::Type ObjectType() const {return HPS::Type::VisibilityKit;};
9575 
9579  static VisibilityKit GetDefault();
9580 
9583  void Set(VisibilityKit const & in_kit);
9584 
9587  void Show(VisibilityKit & out_kit) const;
9588 
9592  VisibilityKit & operator=(VisibilityKit const & in_kit);
9593 
9596  bool Empty() const;
9597 
9601  bool Equals(VisibilityKit const & in_kit) const;
9602 
9606  bool operator==(VisibilityKit const & in_kit) const;
9607 
9611  bool operator!=(VisibilityKit const & in_kit) const;
9612 
9613 
9617  VisibilityKit & SetCuttingSections(bool in_state);
9618 
9622  VisibilityKit & SetCutEdges(bool in_state);
9623 
9627  VisibilityKit & SetCutFaces(bool in_state);
9628 
9632  VisibilityKit & SetWindows(bool in_state);
9633 
9637  VisibilityKit & SetText(bool in_state);
9638 
9642  VisibilityKit & SetLines(bool in_state);
9643 
9647  VisibilityKit & SetEdgeLights(bool in_state);
9648 
9652  VisibilityKit & SetMarkerLights(bool in_state);
9653 
9657  VisibilityKit & SetFaceLights(bool in_state);
9658 
9662  VisibilityKit & SetGenericEdges(bool in_state);
9663 
9667  VisibilityKit & SetInteriorSilhouetteEdges(bool in_state);
9668 
9675  VisibilityKit & SetAdjacentEdges(bool in_state);
9676 
9680  VisibilityKit & SetHardEdges(bool in_state);
9681 
9685  VisibilityKit & SetMeshQuadEdges(bool in_state);
9686 
9690  VisibilityKit & SetNonCulledEdges(bool in_state);
9691 
9695  VisibilityKit & SetPerimeterEdges(bool in_state);
9696 
9700  VisibilityKit & SetFaces(bool in_state);
9701 
9705  VisibilityKit & SetVertices(bool in_state);
9706 
9710  VisibilityKit & SetMarkers(bool in_state);
9711 
9715  VisibilityKit & SetShadowCasting(bool in_state);
9716 
9720  VisibilityKit & SetShadowReceiving(bool in_state);
9721 
9725  VisibilityKit & SetShadowEmitting(bool in_state);
9726 
9727 
9731  VisibilityKit & SetCutGeometry(bool in_state);
9732 
9736  VisibilityKit & SetEdges(bool in_state);
9737 
9741  VisibilityKit & SetGeometry(bool in_state);
9742 
9746  VisibilityKit & SetLights(bool in_state);
9747 
9751  VisibilityKit & SetShadows(bool in_state);
9752 
9756  VisibilityKit & SetEverything(bool in_state);
9757 
9758 
9761  VisibilityKit & UnsetCuttingSections();
9762 
9765  VisibilityKit & UnsetCutEdges();
9766 
9769  VisibilityKit & UnsetCutFaces();
9770 
9773  VisibilityKit & UnsetWindows();
9774 
9777  VisibilityKit & UnsetText();
9778 
9781  VisibilityKit & UnsetLines();
9782 
9785  VisibilityKit & UnsetEdgeLights();
9786 
9789  VisibilityKit & UnsetMarkerLights();
9790 
9793  VisibilityKit & UnsetFaceLights();
9794 
9797  VisibilityKit & UnsetGenericEdges();
9798 
9801  VisibilityKit & UnsetInteriorSilhouetteEdges();
9802 
9805  VisibilityKit & UnsetAdjacentEdges();
9806 
9809  VisibilityKit & UnsetHardEdges();
9810 
9813  VisibilityKit & UnsetMeshQuadEdges();
9814 
9817  VisibilityKit & UnsetNonCulledEdges();
9818 
9821  VisibilityKit & UnsetPerimeterEdges();
9822 
9825  VisibilityKit & UnsetFaces();
9826 
9829  VisibilityKit & UnsetVertices();
9830 
9833  VisibilityKit & UnsetMarkers();
9834 
9837  VisibilityKit & UnsetShadowCasting();
9838 
9841  VisibilityKit & UnsetShadowReceiving();
9842 
9845  VisibilityKit & UnsetShadowEmitting();
9846 
9847 
9850  VisibilityKit & UnsetCutGeometry();
9851 
9854  VisibilityKit & UnsetEdges();
9855 
9858  VisibilityKit & UnsetGeometry();
9859 
9862  VisibilityKit & UnsetLights();
9863 
9866  VisibilityKit & UnsetShadows();
9867 
9870  VisibilityKit & UnsetEverything();
9871 
9872 
9876  bool ShowCuttingSections(bool & out_state) const;
9877 
9881  bool ShowCutEdges(bool & out_state) const;
9882 
9886  bool ShowCutFaces(bool & out_state) const;
9887 
9891  bool ShowWindows(bool & out_state) const;
9892 
9896  bool ShowText(bool & out_state) const;
9897 
9901  bool ShowLines(bool & out_state) const;
9902 
9906  bool ShowEdgeLights(bool & out_state) const;
9907 
9911  bool ShowMarkerLights(bool & out_state) const;
9912 
9916  bool ShowFaceLights(bool & out_state) const;
9917 
9921  bool ShowGenericEdges(bool & out_state) const;
9922 
9926  bool ShowInteriorSilhouetteEdges(bool & out_state) const;
9927 
9931  bool ShowAdjacentEdges(bool & out_state) const;
9932 
9936  bool ShowHardEdges(bool & out_state) const;
9937 
9941  bool ShowMeshQuadEdges(bool & out_state) const;
9942 
9946  bool ShowNonCulledEdges(bool & out_state) const;
9947 
9951  bool ShowPerimeterEdges(bool & out_state) const;
9952 
9956  bool ShowFaces(bool & out_state) const;
9957 
9961  bool ShowVertices(bool & out_state) const;
9962 
9966  bool ShowMarkers(bool & out_state) const;
9967 
9971  bool ShowShadowCasting(bool & out_state) const;
9972 
9976  bool ShowShadowReceiving(bool & out_state) const;
9977 
9981  bool ShowShadowEmitting(bool & out_state) const;
9982 };
9983 
9984 
9990 class HPS_API VisibilityControl : public Control
9991 {
9992 public:
9993 
9995  explicit VisibilityControl(SegmentKey & in_seg);
9996 
9998  VisibilityControl(VisibilityControl const & in_that);
9999 
10004 
10008  VisibilityControl & operator=(VisibilityControl && in_that);
10009 
10011  ~VisibilityControl();
10012 
10013  HPS::Type ObjectType() const {return HPS::Type::VisibilityControl;};
10014 
10018  VisibilityControl & operator=(VisibilityControl const & in_that);
10019 
10023  VisibilityControl & SetCuttingSections(bool in_state);
10024 
10028  VisibilityControl & SetCutEdges(bool in_state);
10029 
10033  VisibilityControl & SetCutFaces(bool in_state);
10034 
10038  VisibilityControl & SetWindows(bool in_state);
10039 
10043  VisibilityControl & SetText(bool in_state);
10044 
10048  VisibilityControl & SetLines(bool in_state);
10049 
10053  VisibilityControl & SetEdgeLights(bool in_state);
10054 
10058  VisibilityControl & SetMarkerLights(bool in_state);
10059 
10063  VisibilityControl & SetFaceLights(bool in_state);
10064 
10068  VisibilityControl & SetGenericEdges(bool in_state);
10069 
10073  VisibilityControl & SetInteriorSilhouetteEdges(bool in_state);
10074 
10078  VisibilityControl & SetAdjacentEdges(bool in_state);
10079 
10083  VisibilityControl & SetHardEdges(bool in_state);
10084 
10088  VisibilityControl & SetMeshQuadEdges(bool in_state);
10089 
10093  VisibilityControl & SetNonCulledEdges(bool in_state);
10094 
10098  VisibilityControl & SetPerimeterEdges(bool in_state);
10099 
10103  VisibilityControl & SetFaces(bool in_state);
10104 
10108  VisibilityControl & SetVertices(bool in_state);
10109 
10113  VisibilityControl & SetMarkers(bool in_state);
10114 
10118  VisibilityControl & SetShadowCasting(bool in_state);
10119 
10123  VisibilityControl & SetShadowReceiving(bool in_state);
10124 
10128  VisibilityControl & SetShadowEmitting(bool in_state);
10129 
10130 
10134  VisibilityControl & SetCutGeometry(bool in_state);
10135 
10139  VisibilityControl & SetEdges(bool in_state);
10140 
10144  VisibilityControl & SetGeometry(bool in_state);
10145 
10149  VisibilityControl & SetLights(bool in_state);
10150 
10154  VisibilityControl & SetShadows(bool in_state);
10155 
10159  VisibilityControl & SetEverything(bool in_state);
10160 
10161 
10164  VisibilityControl & UnsetCuttingSections();
10165 
10168  VisibilityControl & UnsetCutEdges();
10169 
10172  VisibilityControl & UnsetCutFaces();
10173 
10176  VisibilityControl & UnsetWindows();
10177 
10180  VisibilityControl & UnsetText();
10181 
10184  VisibilityControl & UnsetLines();
10185 
10188  VisibilityControl & UnsetEdgeLights();
10189 
10192  VisibilityControl & UnsetMarkerLights();
10193 
10196  VisibilityControl & UnsetFaceLights();
10197 
10200  VisibilityControl & UnsetGenericEdges();
10201 
10204  VisibilityControl & UnsetInteriorSilhouetteEdges();
10205 
10208  VisibilityControl & UnsetAdjacentEdges();
10209 
10212  VisibilityControl & UnsetHardEdges();
10213 
10216  VisibilityControl & UnsetMeshQuadEdges();
10217 
10220  VisibilityControl & UnsetNonCulledEdges();
10221 
10224  VisibilityControl & UnsetPerimeterEdges();
10225 
10228  VisibilityControl & UnsetFaces();
10229 
10232  VisibilityControl & UnsetVertices();
10233 
10236  VisibilityControl & UnsetMarkers();
10237 
10240  VisibilityControl & UnsetShadowCasting();
10241 
10244  VisibilityControl & UnsetShadowReceiving();
10245 
10248  VisibilityControl & UnsetShadowEmitting();
10249 
10250 
10253  VisibilityControl & UnsetCutGeometry();
10254 
10257  VisibilityControl & UnsetEdges();
10258 
10261  VisibilityControl & UnsetGeometry();
10262 
10265  VisibilityControl & UnsetLights();
10266 
10269  VisibilityControl & UnsetShadows();
10270 
10273  VisibilityControl & UnsetEverything();
10274 
10275 
10279  bool ShowCuttingSections(bool & out_state) const;
10280 
10284  bool ShowCutEdges(bool & out_state) const;
10285 
10289  bool ShowCutFaces(bool & out_state) const;
10290 
10294  bool ShowWindows(bool & out_state) const;
10295 
10299  bool ShowText(bool & out_state) const;
10300 
10304  bool ShowLines(bool & out_state) const;
10305 
10309  bool ShowEdgeLights(bool & out_state) const;
10310 
10314  bool ShowMarkerLights(bool & out_state) const;
10315 
10319  bool ShowFaceLights(bool & out_state) const;
10320 
10324  bool ShowGenericEdges(bool & out_state) const;
10325 
10329  bool ShowInteriorSilhouetteEdges(bool & out_state) const;
10330 
10334  bool ShowAdjacentEdges(bool & out_state) const;
10335 
10339  bool ShowHardEdges(bool & out_state) const;
10340 
10344  bool ShowMeshQuadEdges(bool & out_state) const;
10345 
10349  bool ShowNonCulledEdges(bool & out_state) const;
10350 
10354  bool ShowPerimeterEdges(bool & out_state) const;
10355 
10359  bool ShowFaces(bool & out_state) const;
10360 
10364  bool ShowVertices(bool & out_state) const;
10365 
10369  bool ShowMarkers(bool & out_state) const;
10370 
10374  bool ShowShadowCasting(bool & out_state) const;
10375 
10379  bool ShowShadowReceiving(bool & out_state) const;
10380 
10384  bool ShowShadowEmitting(bool & out_state) const;
10385 
10386 private:
10389 };
10390 
10391 
10392 
10395 class HPS_API CameraKit : public Object
10396 {
10397 public:
10398 
10400  CameraKit();
10401 
10404  CameraKit(const CameraKit & in_kit);
10405 
10409  CameraKit(CameraKit && in_that);
10410 
10414  CameraKit & operator=(CameraKit && in_that);
10415 
10417  virtual ~CameraKit();
10418 
10419  HPS::Type ObjectType() const {return HPS::Type::CameraKit;};
10420 
10424  static CameraKit GetDefault();
10425 
10428  void Set(CameraKit const & in_kit);
10429 
10432  void Show(CameraKit & out_kit) const;
10433 
10437  CameraKit & operator=(CameraKit const & in_kit);
10438 
10441  bool Empty() const;
10442 
10446  bool Equals(CameraKit const & in_kit) const;
10447 
10451  bool operator==(CameraKit const & in_kit) const;
10452 
10456  bool operator!=(CameraKit const & in_kit) const;
10457 
10461  CameraKit & SetUpVector(Vector const & in_up);
10462 
10466  CameraKit & SetPosition(Point const & in_position);
10467 
10471  CameraKit & SetTarget(Point const & in_target);
10472 
10479  CameraKit & SetProjection(Camera::Projection in_type, float in_oblique_y_skew = 0.0f, float in_oblique_x_skew = 0.0f);
10480 
10486  CameraKit & SetField(float in_width, float in_height);
10487 
10497  CameraKit & SetNearLimit(float const in_limit);
10498 
10501  CameraKit & UnsetUpVector();
10502 
10505  CameraKit & UnsetPosition();
10506 
10509  CameraKit & UnsetTarget();
10510 
10513  CameraKit & UnsetProjection();
10514 
10517  CameraKit & UnsetField();
10518 
10521  CameraKit & UnsetNearLimit();
10522 
10525  CameraKit & UnsetEverything();
10526 
10527 
10531  bool ShowUpVector(Vector & out_up_vector) const;
10532 
10536  bool ShowPosition(Point & out_position) const;
10537 
10541  bool ShowTarget(Point & out_target) const;
10542 
10546  bool ShowProjection(Camera::Projection & out_type) const;
10547 
10553  bool ShowProjection(Camera::Projection & out_type, float & out_oblique_y_skew, float & out_oblique_x_skew) const;
10554 
10558  bool ShowWidth(float & out_width) const;
10559 
10563  bool ShowHeight(float & out_height) const;
10564 
10569  bool ShowField(float & out_width, float & out_height) const;
10570 
10574  bool ShowNearLimit(float & out_near_limit) const;
10575 
10582  CameraKit & Dolly(float in_x_dir, float in_up, float in_forward);
10583 
10590  CameraKit & Orbit(float in_theta, float in_phi);
10591 
10598  CameraKit & Pan(float in_theta, float in_phi);
10599 
10605  CameraKit & Roll(float in_theta);
10606 
10612  CameraKit & Zoom(float in_zoom);
10613 };
10614 
10618 class HPS_API CameraControl : public Control
10619 {
10620 public:
10622  explicit CameraControl(SegmentKey & in_seg);
10623 
10625  CameraControl(CameraControl const & in_that);
10626 
10630  CameraControl(CameraControl && in_that);
10631 
10635  CameraControl & operator=(CameraControl && in_that);
10636 
10638  ~CameraControl();
10639 
10640  HPS::Type ObjectType() const {return HPS::Type::CameraControl;};
10641 
10645  CameraControl & operator=(CameraControl const & in_that);
10646 
10651  CameraControl & SetUpVector(Vector const & in_up);
10652 
10657  CameraControl & SetPosition(Point const & in_position);
10658 
10663  CameraControl & SetTarget(Point const & in_target);
10664 
10671  CameraControl & SetProjection(Camera::Projection in_type, float in_oblique_x_skew = 0.0f, float in_oblique_y_skew = 0.0f);
10672 
10678  CameraControl & SetField(float in_width, float in_height);
10679 
10690  CameraControl & SetNearLimit(float in_double);
10691 
10695  CameraControl & UnsetEverything();
10696 
10697 
10701  bool ShowUpVector(Vector & out_up_vector) const;
10702 
10706  bool ShowPosition(Point & out_position) const;
10707 
10711  bool ShowTarget(Point & out_target) const;
10712 
10716  bool ShowProjection(Camera::Projection & out_type) const;
10717 
10723  bool ShowProjection(Camera::Projection & out_type, float & out_oblique_x_skew, float & out_oblique_y_skew) const;
10724 
10728  bool ShowWidth(float & out_width) const;
10729 
10733  bool ShowHeight(float & out_height) const;
10734 
10739  bool ShowField(float & out_width, float & out_height) const;
10740 
10744  bool ShowNearLimit(float & out_width) const;
10745 
10752  CameraControl & Dolly(float in_x_dir, float in_up, float in_forward);
10753 
10760  CameraControl & Orbit(float in_theta, float in_phi);
10761 
10768  CameraControl & Pan(float in_theta, float in_phi);
10769 
10775  CameraControl & Roll(float in_theta);
10776 
10782  CameraControl & Zoom(float in_zoom);
10783 
10784 private:
10786  CameraControl();
10787 };
10788 
10789 
10790 
10792 class HPS_API SelectabilityKit : public Object
10793 {
10794 public:
10795 
10797  SelectabilityKit();
10798 
10801  SelectabilityKit(SelectabilityKit const & in_kit);
10802 
10806  SelectabilityKit(SelectabilityKit && in_that);
10807 
10811  SelectabilityKit & operator=(SelectabilityKit && in_that);
10812 
10814  virtual ~SelectabilityKit();
10815 
10816  HPS::Type ObjectType() const {return HPS::Type::SelectabilityKit;};
10817 
10821  static SelectabilityKit GetDefault();
10822 
10825  void Set(SelectabilityKit const & in_kit);
10826 
10829  void Show(SelectabilityKit & out_kit) const;
10830 
10834  SelectabilityKit & operator=(SelectabilityKit const & in_kit);
10835 
10838  bool Empty() const;
10839 
10843  bool Equals(SelectabilityKit const & in_kit) const;
10844 
10848  bool operator==(SelectabilityKit const & in_kit) const;
10849 
10853  bool operator!=(SelectabilityKit const & in_kit) const;
10854 
10855 
10859  SelectabilityKit & SetWindows(Selectability::Value in_val);
10860 
10864  SelectabilityKit & SetEdges(Selectability::Value in_val);
10865 
10869  SelectabilityKit & SetFaces(Selectability::Value in_val);
10870 
10874  SelectabilityKit & SetLights(Selectability::Value in_val);
10875 
10879  SelectabilityKit & SetLines(Selectability::Value in_val);
10880 
10884  SelectabilityKit & SetMarkers(Selectability::Value in_val);
10885 
10889  SelectabilityKit & SetVertices(Selectability::Value in_val);
10890 
10894  SelectabilityKit & SetText(Selectability::Value in_val);
10895 
10899  SelectabilityKit & SetGeometry(Selectability::Value in_val);
10900 
10904  SelectabilityKit & SetEverything(Selectability::Value in_val);
10905 
10906 
10909  SelectabilityKit & UnsetWindows();
10910 
10913  SelectabilityKit & UnsetEdges();
10914 
10917  SelectabilityKit & UnsetFaces();
10918 
10921  SelectabilityKit & UnsetLights();
10922 
10925  SelectabilityKit & UnsetLines();
10926 
10929  SelectabilityKit & UnsetMarkers();
10930 
10933  SelectabilityKit & UnsetVertices();
10934 
10937  SelectabilityKit & UnsetText();
10938 
10941  SelectabilityKit & UnsetGeometry();
10942 
10945  SelectabilityKit & UnsetEverything();
10946 
10947 
10951  bool ShowWindows(Selectability::Value & out_val) const;
10952 
10956  bool ShowEdges(Selectability::Value & out_val) const;
10957 
10961  bool ShowFaces(Selectability::Value & out_val) const;
10962 
10966  bool ShowLights(Selectability::Value & out_val) const;
10967 
10971  bool ShowLines(Selectability::Value & out_val) const;
10972 
10976  bool ShowMarkers(Selectability::Value & out_val) const;
10977 
10981  bool ShowVertices(Selectability::Value & out_val) const;
10982 
10986  bool ShowText(Selectability::Value & out_val) const;
10987 };
10988 
10994 class HPS_API SelectabilityControl : public Control
10995 {
10996 public:
10997 
10999  explicit SelectabilityControl(SegmentKey & in_seg);
11000 
11002  SelectabilityControl(SelectabilityControl const & in_that);
11003 
11008 
11012  SelectabilityControl & operator=(SelectabilityControl && in_that);
11013 
11016 
11017  HPS::Type ObjectType() const {return HPS::Type::SelectabilityControl;};
11018 
11022  SelectabilityControl & operator=(SelectabilityControl const & in_that);
11023 
11027  SelectabilityControl & SetWindows(Selectability::Value in_val);
11028 
11032  SelectabilityControl & SetEdges(Selectability::Value in_val);
11033 
11037  SelectabilityControl & SetFaces(Selectability::Value in_val);
11038 
11042  SelectabilityControl & SetLights(Selectability::Value in_val);
11043 
11047  SelectabilityControl & SetLines(Selectability::Value in_val);
11048 
11052  SelectabilityControl & SetMarkers(Selectability::Value in_val);
11053 
11057  SelectabilityControl & SetVertices(Selectability::Value in_val);
11058 
11062  SelectabilityControl & SetText(Selectability::Value in_val);
11063 
11067  SelectabilityControl & SetGeometry(Selectability::Value in_val);
11068 
11072  SelectabilityControl & SetEverything(Selectability::Value in_val);
11073 
11074 
11077  SelectabilityControl & UnsetWindows();
11078 
11081  SelectabilityControl & UnsetEdges();
11082 
11085  SelectabilityControl & UnsetFaces();
11086 
11089  SelectabilityControl & UnsetLights();
11090 
11093  SelectabilityControl & UnsetLines();
11094 
11097  SelectabilityControl & UnsetMarkers();
11098 
11101  SelectabilityControl & UnsetVertices();
11102 
11105  SelectabilityControl & UnsetText();
11106 
11109  SelectabilityControl & UnsetGeometry();
11110 
11113  SelectabilityControl & UnsetEverything();
11114 
11115 
11119  bool ShowWindows(Selectability::Value & out_val) const;
11120 
11124  bool ShowEdges(Selectability::Value & out_val) const;
11125 
11129  bool ShowFaces(Selectability::Value & out_val) const;
11130 
11134  bool ShowLights(Selectability::Value & out_val) const;
11135 
11139  bool ShowLines(Selectability::Value & out_val) const;
11140 
11144  bool ShowMarkers(Selectability::Value & out_val) const;
11145 
11149  bool ShowVertices(Selectability::Value & out_val) const;
11150 
11154  bool ShowText(Selectability::Value & out_val) const;
11155 
11156 private:
11159 };
11160 
11161 
11163 class HPS_API TransparencyKit : public Object
11164 {
11165 public:
11166 
11168  TransparencyKit();
11169 
11172  TransparencyKit(TransparencyKit const & in_kit);
11173 
11177  TransparencyKit(TransparencyKit && in_that);
11178 
11182  TransparencyKit & operator=(TransparencyKit && in_that);
11183 
11185  virtual ~TransparencyKit();
11186 
11187  HPS::Type ObjectType() const {return HPS::Type::TransparencyKit;};
11188 
11192  static TransparencyKit GetDefault();
11193 
11196  void Set(TransparencyKit const & in_kit);
11197 
11200  void Show(TransparencyKit & out_kit) const;
11201 
11205  TransparencyKit & operator=(TransparencyKit const & in_kit);
11206 
11209  bool Empty() const;
11210 
11214  bool Equals(TransparencyKit const & in_kit) const;
11215 
11219  bool operator==(TransparencyKit const & in_kit) const;
11220 
11224  bool operator!=(TransparencyKit const & in_kit) const;
11225 
11226 
11230  TransparencyKit & SetMethod(Transparency::Method in_style);
11231 
11235  TransparencyKit & SetAlgorithm(Transparency::Algorithm in_algorithm);
11236 
11241  TransparencyKit & SetDepthPeelingLayers(unsigned int in_layers);
11242 
11248  TransparencyKit & SetDepthPeelingMinimumArea(float in_area, Transparency::AreaUnits in_units);
11249 
11254  TransparencyKit & SetDepthWriting(bool in_state);
11255 
11256 
11259  TransparencyKit & UnsetMethod();
11260 
11263  TransparencyKit & UnsetAlgorithm();
11264 
11267  TransparencyKit & UnsetDepthPeelingLayers();
11268 
11271  TransparencyKit & UnsetDepthPeelingMinimumArea();
11272 
11275  TransparencyKit & UnsetDepthWriting();
11276 
11279  TransparencyKit & UnsetEverything();
11280 
11281 
11285  bool ShowMethod(Transparency::Method & out_style) const;
11286 
11290  bool ShowAlgorithm(Transparency::Algorithm & out_algorithm) const;
11291 
11295  bool ShowDepthPeelingLayers(unsigned int & out_layers) const;
11296 
11301  bool ShowDepthPeelingMinimumArea(float & out_area, Transparency::AreaUnits & out_units) const;
11302 
11306  bool ShowDepthWriting(bool & out_state) const;
11307 };
11308 
11314 class HPS_API TransparencyControl : public Control
11315 {
11316 public:
11317 
11319  explicit TransparencyControl(SegmentKey & in_seg);
11320 
11322  TransparencyControl(TransparencyControl const & in_that);
11323 
11328 
11332  TransparencyControl & operator=(TransparencyControl && in_that);
11333 
11336 
11337  HPS::Type ObjectType() const {return HPS::Type::TransparencyControl;};
11338 
11342  TransparencyControl & operator=(TransparencyControl const & in_that);
11343 
11347  TransparencyControl & SetMethod(Transparency::Method in_style);
11348 
11352  TransparencyControl & SetAlgorithm(Transparency::Algorithm in_algorithm);
11353 
11358  TransparencyControl & SetDepthPeelingLayers(unsigned int in_layers);
11359 
11365  TransparencyControl & SetDepthPeelingMinimumArea(float in_area, Transparency::AreaUnits in_units);
11366 
11371  TransparencyControl & SetDepthWriting(bool in_state);
11372 
11373 
11376  TransparencyControl & UnsetMethod();
11377 
11380  TransparencyControl & UnsetAlgorithm();
11381 
11384  TransparencyControl & UnsetDepthPeelingLayers();
11385 
11388  TransparencyControl & UnsetDepthPeelingMinimumArea();
11389 
11392  TransparencyControl & UnsetDepthWriting();
11393 
11396  TransparencyControl & UnsetEverything();
11397 
11398 
11402  bool ShowMethod(Transparency::Method & out_style) const;
11403 
11407  bool ShowAlgorithm(Transparency::Algorithm & out_algorithm) const;
11408 
11412  bool ShowDepthPeelingLayers(unsigned int & out_layers) const;
11413 
11418  bool ShowDepthPeelingMinimumArea(float & out_area, Transparency::AreaUnits & out_units) const;
11419 
11423  bool ShowDepthWriting(bool & out_state) const;
11424 
11425 private:
11428 };
11429 
11431 class HPS_API ColorInterpolationKit : public Object
11432 {
11433 public:
11434 
11437 
11440 
11445 
11449  ColorInterpolationKit & operator=(ColorInterpolationKit && in_that);
11450 
11452  virtual ~ColorInterpolationKit();
11453 
11454  HPS::Type ObjectType() const {return HPS::Type::ColorInterpolationKit;};
11455 
11456  static ColorInterpolationKit GetDefault();
11457 
11459  void Set(ColorInterpolationKit const & in_kit);
11460 
11462  void Show(ColorInterpolationKit & out_kit) const;
11463 
11465  ColorInterpolationKit & operator=(ColorInterpolationKit const & in_kit);
11466 
11468  bool Empty() const;
11469 
11471  bool Equals(ColorInterpolationKit const & in_kit) const;
11472 
11474  bool operator==(ColorInterpolationKit const & in_kit) const;
11475 
11477  bool operator!=(ColorInterpolationKit const & in_kit) const;
11478 
11479 
11483  ColorInterpolationKit & SetFaceColor(bool in_state);
11484 
11488  ColorInterpolationKit & SetEdgeColor(bool in_state);
11489 
11493  ColorInterpolationKit & SetVertexColor(bool in_state);
11494 
11498  ColorInterpolationKit & SetFaceIndex(bool in_state);
11499 
11503  ColorInterpolationKit & SetEdgeIndex(bool in_state);
11504 
11508  ColorInterpolationKit & SetVertexIndex(bool in_state);
11509 
11510 
11513  ColorInterpolationKit & UnsetFaceColor();
11514 
11517  ColorInterpolationKit & UnsetEdgeColor();
11518 
11521  ColorInterpolationKit & UnsetVertexColor();
11522 
11525  ColorInterpolationKit & UnsetFaceIndex();
11526 
11529  ColorInterpolationKit & UnsetEdgeIndex();
11530 
11533  ColorInterpolationKit & UnsetVertexIndex();
11534 
11537  ColorInterpolationKit & UnsetEverything();
11538 
11539 
11543  bool ShowFaceColor(bool & out_state) const;
11544 
11548  bool ShowEdgeColor(bool & out_state) const;
11549 
11553  bool ShowVertexColor(bool & out_state) const;
11554 
11558  bool ShowFaceIndex(bool & out_state) const;
11559 
11563  bool ShowEdgeIndex(bool & out_state) const;
11564 
11568  bool ShowVertexIndex(bool & out_state) const;
11569 };
11570 
11571 
11575 class HPS_API ColorInterpolationControl : public Control
11576 {
11577 public:
11578 
11580  explicit ColorInterpolationControl(SegmentKey & in_seg);
11581 
11584 
11589 
11593  ColorInterpolationControl & operator=(ColorInterpolationControl && in_that);
11594 
11597 
11598  HPS::Type ObjectType() const {return HPS::Type::ColorInterpolationControl;};
11599 
11603  ColorInterpolationControl & operator=(ColorInterpolationControl const & in_that);
11604 
11608  ColorInterpolationControl & SetFaceColor(bool in_state);
11609 
11613  ColorInterpolationControl & SetEdgeColor(bool in_state);
11614 
11618  ColorInterpolationControl & SetVertexColor(bool in_state);
11619 
11623  ColorInterpolationControl & SetFaceIndex(bool in_state);
11624 
11628  ColorInterpolationControl & SetEdgeIndex(bool in_state);
11629 
11633  ColorInterpolationControl & SetVertexIndex(bool in_state);
11634 
11635 
11638  ColorInterpolationControl & UnsetFaceColor();
11639 
11642  ColorInterpolationControl & UnsetEdgeColor();
11643 
11646  ColorInterpolationControl & UnsetVertexColor();
11647 
11650  ColorInterpolationControl & UnsetFaceIndex();
11651 
11654  ColorInterpolationControl & UnsetEdgeIndex();
11655 
11658  ColorInterpolationControl & UnsetVertexIndex();
11659 
11662  ColorInterpolationControl & UnsetEverything();
11663 
11664 
11668  bool ShowFaceColor(bool & out_state) const;
11669 
11673  bool ShowEdgeColor(bool & out_state) const;
11674 
11678  bool ShowVertexColor(bool & out_state) const;
11679 
11683  bool ShowFaceIndex(bool & out_state) const;
11684 
11688  bool ShowEdgeIndex(bool & out_state) const;
11689 
11693  bool ShowVertexIndex(bool & out_state) const;
11694 
11695 private:
11698 };
11699 
11700 
11702 class HPS_API CullingKit : public Object
11703 {
11704 public:
11705 
11707  CullingKit();
11708 
11711  CullingKit(CullingKit const & in_kit);
11712 
11716  CullingKit(CullingKit && in_that);
11717 
11721  CullingKit & operator=(CullingKit && in_that);
11722 
11724  virtual ~CullingKit();
11725 
11726  HPS::Type ObjectType() const {return HPS::Type::CullingKit;};
11727 
11731  static CullingKit GetDefault();
11732 
11735  void Set(CullingKit const & in_kit);
11736 
11739  void Show(CullingKit & out_kit) const;
11740 
11744  CullingKit & operator=(CullingKit const & in_kit);
11745 
11748  bool Empty() const;
11749 
11753  bool Equals(CullingKit const & in_kit) const;
11754 
11758  bool operator==(CullingKit const & in_kit) const;
11759 
11763  bool operator!=(CullingKit const & in_kit) const;
11764 
11769  CullingKit & SetDeferralExtent(bool in_state, unsigned int in_pixels);
11770 
11775  CullingKit & SetDeferralExtent(unsigned int in_pixels);
11776 
11781  CullingKit & SetExtent(bool in_state, unsigned int in_pixels);
11782 
11787  CullingKit & SetExtent(unsigned int in_pixels);
11788 
11792  CullingKit & SetBackFace(bool in_state);
11793 
11800  CullingKit & SetVector(bool in_state, HPS::Vector const & in_vector, float in_tolerance_degrees);
11801 
11808  CullingKit & SetVector(HPS::Vector const & in_vector, float in_tolerance_degrees);
11809 
11816  CullingKit & SetVector(bool in_state, HPS::Vector const & in_vector = Vector(0.0f, 0.0f, 1.0f));
11817 
11823  CullingKit & SetVector(HPS::Vector const & in_vector);
11824 
11828  CullingKit & SetVectorTolerance(float in_tolerance_degrees);
11829 
11833  CullingKit & SetFrustum(bool in_state);
11834 
11837  CullingKit & UnsetDeferralExtent();
11838 
11841  CullingKit & UnsetExtent();
11842 
11845  CullingKit & UnsetBackFace();
11846 
11849  CullingKit & UnsetVector();
11850 
11853  CullingKit & UnsetVectorTolerance();
11854 
11857  CullingKit & UnsetFrustum();
11858 
11861  CullingKit & UnsetEverything();
11862 
11867  bool ShowDeferralExtent(bool & out_state, unsigned int & out_pixels) const;
11868 
11873  bool ShowExtent(bool & out_state, unsigned int & out_pixels) const;
11874 
11878  bool ShowBackFace(bool & out_state) const;
11879 
11885  bool ShowVector(bool & out_state, HPS::Vector & out_vector) const;
11886 
11890  bool ShowVectorTolerance(float & out_tolerance_degrees) const;
11891 
11895  bool ShowFrustum(bool & out_state) const;
11896 };
11897 
11901 class HPS_API CullingControl : public Control
11902 {
11903 public:
11904 
11906  explicit CullingControl(SegmentKey & in_seg);
11907 
11909  CullingControl(CullingControl const & in_that);
11910 
11912  ~CullingControl();
11913 
11917  CullingControl(CullingControl && in_that);
11918 
11922  CullingControl & operator=(CullingControl && in_that);
11923 
11924  HPS::Type ObjectType() const {return HPS::Type::CullingControl;};
11925 
11929  CullingControl & operator=(CullingControl const & in_that);
11930 
11937  CullingControl & SetDeferralExtent(bool in_state, unsigned int in_pixels);
11938 
11945  CullingControl & SetDeferralExtent(unsigned int in_pixels);
11946 
11951  CullingControl & SetExtent(bool in_state, unsigned int in_pixels);
11952 
11957  CullingControl & SetExtent(unsigned int in_pixels);
11958 
11963  CullingControl & SetBackFace(bool in_state);
11964 
11971  CullingControl & SetVector(bool in_state, HPS::Vector const & in_vector, float in_tolerance_degrees);
11972 
11979  CullingControl & SetVector(HPS::Vector const & in_vector, float in_tolerance_degrees);
11980 
11987  CullingControl & SetVector(bool in_state, HPS::Vector const & in_vector = Vector(0.0f, 0.0f, 1.0f));
11988 
11994  CullingControl & SetVector(HPS::Vector const & in_vector);
11995 
11999  CullingControl & SetVectorTolerance(float in_tolerance_degrees);
12000 
12004  CullingControl & SetFrustum(bool in_state);
12005 
12008  CullingControl & UnsetDeferralExtent();
12009 
12012  CullingControl & UnsetExtent();
12013 
12016  CullingControl & UnsetBackFace();
12017 
12020  CullingControl & UnsetVector();
12021 
12024  CullingControl & UnsetVectorTolerance();
12025 
12028  CullingControl & UnsetFrustum();
12029 
12032  CullingControl & UnsetEverything();
12033 
12038  bool ShowDeferralExtent(bool & out_state, unsigned int & out_pixels) const;
12039 
12044  bool ShowExtent(bool & out_state, unsigned int & out_pixels) const;
12045 
12049  bool ShowBackFace(bool & out_state) const;
12050 
12056  bool ShowVector(bool & out_state, HPS::Vector & out_vector) const;
12057 
12061  bool ShowVectorTolerance(float & out_tolerance_degrees) const;
12062 
12066  bool ShowFrustum(bool & out_state) const;
12067 
12068 private:
12070  CullingControl();
12071 };
12072 
12073 
12074 
12075 
12077 class HPS_API MarkerAttributeKit : public Object
12078 {
12079 public:
12080 
12083 
12086  MarkerAttributeKit(MarkerAttributeKit const & in_kit);
12087 
12092 
12096  MarkerAttributeKit & operator=(MarkerAttributeKit && in_that);
12097 
12099  virtual ~MarkerAttributeKit();
12100 
12101  HPS::Type ObjectType() const {return HPS::Type::MarkerAttributeKit;};
12102 
12106  static MarkerAttributeKit GetDefault();
12107 
12110  void Set(MarkerAttributeKit const & in_kit);
12111 
12114  void Show(MarkerAttributeKit & out_kit) const;
12115 
12119  MarkerAttributeKit & operator=(MarkerAttributeKit const & in_kit);
12120 
12123  bool Empty() const;
12124 
12128  bool Equals(MarkerAttributeKit const & in_kit) const;
12129 
12133  bool operator==(MarkerAttributeKit const & in_kit) const;
12134 
12138  bool operator!=(MarkerAttributeKit const & in_kit) const;
12139 
12140 
12144  MarkerAttributeKit & SetSymbol(char const * in_glyph_name);
12145 
12150  MarkerAttributeKit & SetSize(float in_size, Marker::SizeUnits in_units = Marker::SizeUnits::ScaleFactor);
12151 
12152 
12155  MarkerAttributeKit & UnsetSymbol();
12156 
12159  MarkerAttributeKit & UnsetSize();
12160 
12163  MarkerAttributeKit & UnsetEverything();
12164 
12165 
12169  bool ShowSymbol(UTF8 & out_glyph_name) const;
12170 
12175  bool ShowSize(float & out_size, Marker::SizeUnits & out_units) const;
12176 };
12177 
12183 class HPS_API MarkerAttributeControl : public Control
12184 {
12185 public:
12186 
12188  explicit MarkerAttributeControl(SegmentKey & in_seg);
12189 
12192 
12197 
12201  MarkerAttributeControl & operator=(MarkerAttributeControl && in_that);
12202 
12205 
12206  HPS::Type ObjectType() const {return HPS::Type::MarkerAttributeControl;};
12207 
12211  MarkerAttributeControl & operator=(MarkerAttributeControl const & in_that);
12212 
12216  MarkerAttributeControl & SetSymbol(char const * in_glyph_name);
12217 
12222  MarkerAttributeControl & SetSize(float in_size, Marker::SizeUnits in_units = Marker::SizeUnits::ScaleFactor);
12223 
12224 
12227  MarkerAttributeControl & UnsetSymbol();
12228 
12231  MarkerAttributeControl & UnsetSize();
12232 
12235  MarkerAttributeControl & UnsetEverything();
12236 
12237 
12241  bool ShowSymbol(UTF8 & out_glyph_name) const;
12242 
12247  bool ShowSize(float & out_size, Marker::SizeUnits & out_units) const;
12248 
12249 private:
12252 };
12253 
12254 
12256 class HPS_API SphereAttributeKit : public Object
12257 {
12258 public:
12259 
12262 
12265  SphereAttributeKit(SphereAttributeKit const & in_kit);
12266 
12271 
12275  SphereAttributeKit & operator=(SphereAttributeKit && in_that);
12276 
12278  virtual ~SphereAttributeKit();
12279 
12280  HPS::Type ObjectType() const {return HPS::Type::SphereAttributeKit;};
12281 
12285  static SphereAttributeKit GetDefault();
12286 
12289  void Set(SphereAttributeKit const & in_kit);
12290 
12293  void Show(SphereAttributeKit & out_kit) const;
12294 
12298  SphereAttributeKit & operator=(SphereAttributeKit const & in_kit);
12299 
12302  bool Empty() const;
12303 
12307  bool Equals(SphereAttributeKit const & in_kit) const;
12308 
12312  bool operator==(SphereAttributeKit const & in_kit) const;
12313 
12317  bool operator!=(SphereAttributeKit const & in_kit) const;
12318 
12319 
12323  SphereAttributeKit & SetTessellation(size_t in_facets);
12324 
12325 
12328  SphereAttributeKit & UnsetTessellation();
12329 
12332  SphereAttributeKit & UnsetEverything();
12333 
12334 
12338  bool ShowTessellation(size_t & out_facets) const;
12339 };
12340 
12341 
12344 class HPS_API SphereAttributeControl : public Control
12345 {
12346 public:
12347 
12349  explicit SphereAttributeControl(SegmentKey const & in_seg);
12350 
12353 
12358 
12362  SphereAttributeControl & operator=(SphereAttributeControl && in_that);
12363 
12366 
12367  HPS::Type ObjectType() const {return HPS::Type::SphereAttributeControl;};
12368 
12372  SphereAttributeControl & operator=(SphereAttributeControl const & in_that);
12373 
12378  SphereAttributeControl & SetTessellation(size_t in_facets);
12379 
12380 
12383  SphereAttributeControl & UnsetTessellation();
12384 
12387  SphereAttributeControl & UnsetEverything();
12388 
12389 
12393  bool ShowTessellation(size_t & out_facets) const;
12394 
12395 private:
12398 };
12399 
12400 
12402 class HPS_API LightingAttributeKit : public Object
12403 {
12404 public:
12405 
12408 
12412 
12417 
12421  LightingAttributeKit & operator=(LightingAttributeKit && in_that);
12422 
12424  virtual ~LightingAttributeKit();
12425 
12426  HPS::Type ObjectType() const {return HPS::Type::LightingAttributeKit;};
12427 
12431  static LightingAttributeKit GetDefault();
12432 
12435  void Set(LightingAttributeKit const & in_kit);
12436 
12439  void Show(LightingAttributeKit & out_kit) const;
12440 
12444  LightingAttributeKit & operator=(LightingAttributeKit const & in_kit);
12445 
12448  bool Empty() const;
12449 
12453  bool Equals(LightingAttributeKit const & in_kit) const;
12454 
12458  bool operator==(LightingAttributeKit const & in_kit) const;
12459 
12463  bool operator!=(LightingAttributeKit const & in_kit) const;
12464 
12465 
12469  LightingAttributeKit & SetInterpolationAlgorithm(Lighting::InterpolationAlgorithm in_interpolation);
12470 
12471 
12474  LightingAttributeKit & UnsetInterpolationAlgorithm();
12475 
12478  LightingAttributeKit & UnsetEverything();
12479 
12480 
12484  bool ShowInterpolationAlgorithm(Lighting::InterpolationAlgorithm & out_interpolation) const;
12485 };
12486 
12487 
12488 
12494 class HPS_API LightingAttributeControl : public Control
12495 {
12496 public:
12497 
12499  explicit LightingAttributeControl(SegmentKey & in_seg);
12500 
12503 
12508 
12512  LightingAttributeControl & operator=(LightingAttributeControl && in_that);
12513 
12516 
12517  HPS::Type ObjectType() const {return HPS::Type::LightingAttributeControl;};
12518 
12522  LightingAttributeControl & operator=(LightingAttributeControl const & in_that);
12523 
12527  LightingAttributeControl & SetInterpolationAlgorithm(Lighting::InterpolationAlgorithm in_interpolation);
12528 
12529 
12532  LightingAttributeControl & UnsetInterpolationAlgorithm();
12533 
12536  LightingAttributeControl & UnsetEverything();
12537 
12538 
12542  bool ShowInterpolationAlgorithm(Lighting::InterpolationAlgorithm & out_interpolation) const;
12543 
12544 private:
12547 };
12548 
12549 
12550 
12552 class HPS_API CylinderAttributeKit : public Object
12553 {
12554 public:
12555 
12558 
12562 
12567 
12571  CylinderAttributeKit & operator=(CylinderAttributeKit && in_that);
12572 
12574  virtual ~CylinderAttributeKit();
12575 
12576  HPS::Type ObjectType() const {return HPS::Type::CylinderAttributeKit;};
12577 
12581  static CylinderAttributeKit GetDefault();
12582 
12585  void Set(CylinderAttributeKit const & in_kit);
12586 
12589  void Show(CylinderAttributeKit & out_kit) const;
12590 
12594  CylinderAttributeKit & operator=(CylinderAttributeKit const & in_kit);
12595 
12598  bool Empty() const;
12599 
12603  bool Equals(CylinderAttributeKit const & in_kit) const;
12604 
12608  bool operator==(CylinderAttributeKit const & in_kit) const;
12609 
12613  bool operator!=(CylinderAttributeKit const & in_kit) const;
12614 
12615 
12619  CylinderAttributeKit & SetTessellation(size_t in_facets);
12620 
12625  CylinderAttributeKit & SetOrientation(Cylinder::Orientation in_adjust);
12626 
12627 
12630  CylinderAttributeKit & UnsetTessellation();
12631 
12634  CylinderAttributeKit & UnsetOrientation();
12635 
12638  CylinderAttributeKit & UnsetEverything();
12639 
12640 
12644  bool ShowTessellation(size_t & out_facets) const;
12645 
12649  bool ShowOrientation(Cylinder::Orientation & out_orientation) const;
12650 };
12651 
12652 
12653 
12657 class HPS_API CylinderAttributeControl : public Control
12658 {
12659 public:
12660 
12662  explicit CylinderAttributeControl(SegmentKey & in_seg);
12663 
12666 
12671 
12675  CylinderAttributeControl & operator=(CylinderAttributeControl && in_that);
12676 
12679 
12680  HPS::Type ObjectType() const {return HPS::Type::CylinderAttributeControl;};
12681 
12685  CylinderAttributeControl & operator=(CylinderAttributeControl const & in_that);
12686 
12690  CylinderAttributeControl & SetTessellation(size_t in_facets);
12691 
12696  CylinderAttributeControl & SetOrientation(Cylinder::Orientation in_orientation);
12697 
12698 
12701  CylinderAttributeControl & UnsetTessellation();
12702 
12705  CylinderAttributeControl & UnsetOrientation();
12706 
12709  CylinderAttributeControl & UnsetEverything();
12710 
12711 
12715  bool ShowTessellation(size_t & out_facets) const;
12716 
12720  bool ShowOrientation(Cylinder::Orientation & out_adjust) const;
12721 
12722 private:
12725 };
12726 
12727 
12728 
12730 class HPS_API CuttingSectionAttributeKit : public Object
12731 {
12732 public:
12733 
12736 
12740 
12745 
12750 
12752  virtual ~CuttingSectionAttributeKit();
12753 
12754  HPS::Type ObjectType() const {return HPS::Type::CuttingSectionAttributeKit;};
12755 
12759  static CuttingSectionAttributeKit GetDefault();
12760 
12763  void Set(CuttingSectionAttributeKit const & in_kit);
12764 
12767  void Show(CuttingSectionAttributeKit & out_kit) const;
12768 
12772  CuttingSectionAttributeKit & operator=(CuttingSectionAttributeKit const & in_kit);
12773 
12776  bool Empty() const;
12777 
12781  bool Equals(CuttingSectionAttributeKit const & in_kit) const;
12782 
12786  bool operator==(CuttingSectionAttributeKit const & in_kit) const;
12787 
12791  bool operator!=(CuttingSectionAttributeKit const & in_kit) const;
12792 
12793 
12797  CuttingSectionAttributeKit & SetCuttingLevel(CuttingSection::CuttingLevel in_level);
12798 
12802  CuttingSectionAttributeKit & SetCappingLevel(CuttingSection::CappingLevel in_level);
12803 
12807  CuttingSectionAttributeKit & SetMaterialPreference(CuttingSection::MaterialPreference in_preference);
12808 
12809 
12812  CuttingSectionAttributeKit & UnsetCuttingLevel();
12813 
12816  CuttingSectionAttributeKit & UnsetCappingLevel();
12817 
12820  CuttingSectionAttributeKit & UnsetMaterialPreference();
12821 
12824  CuttingSectionAttributeKit & UnsetEverything();
12825 
12826 
12830  bool ShowCuttingLevel(CuttingSection::CuttingLevel & out_level) const;
12831 
12835  bool ShowCappingLevel(CuttingSection::CappingLevel & out_level) const;
12836 
12840  bool ShowMaterialPreference(CuttingSection::MaterialPreference & out_preference) const;
12841 };
12842 
12843 
12844 
12849 {
12850 public:
12851 
12853  explicit CuttingSectionAttributeControl(SegmentKey & in_seg);
12854 
12857 
12862 
12867 
12870 
12871  HPS::Type ObjectType() const {return HPS::Type::CuttingSectionAttributeControl;};
12872 
12877 
12882 
12887 
12891  CuttingSectionAttributeControl & SetMaterialPreference(CuttingSection::MaterialPreference in_preference);
12892 
12893 
12896  CuttingSectionAttributeControl & UnsetCuttingLevel();
12897 
12900  CuttingSectionAttributeControl & UnsetCappingLevel();
12901 
12904  CuttingSectionAttributeControl & UnsetMaterialPreference();
12905 
12908  CuttingSectionAttributeControl & UnsetEverything();
12909 
12910 
12914  bool ShowCuttingLevel(CuttingSection::CuttingLevel & out_level) const;
12915 
12919  bool ShowCappingLevel(CuttingSection::CappingLevel & out_level) const;
12920 
12924  bool ShowMaterialPreference(CuttingSection::MaterialPreference & out_preference) const;
12925 
12926 private:
12929 };
12930 
12931 
12932 
12934 class HPS_API TextAttributeKit : public Object
12935 {
12936 public:
12937 
12939  TextAttributeKit();
12940 
12943  TextAttributeKit(TextAttributeKit const & in_kit);
12944 
12948  TextAttributeKit(TextAttributeKit && in_that);
12949 
12953  TextAttributeKit & operator=(TextAttributeKit && in_that);
12954 
12956  virtual ~TextAttributeKit();
12957 
12958  HPS::Type ObjectType() const {return HPS::Type::TextAttributeKit;};
12959 
12963  static TextAttributeKit GetDefault();
12964 
12967  void Set(TextAttributeKit const & in_kit);
12968 
12971  void Show(TextAttributeKit & out_kit) const;
12972 
12976  TextAttributeKit & operator=(TextAttributeKit const & in_kit);
12977 
12980  bool Empty() const;
12981 
12985  bool Equals(TextAttributeKit const & in_kit) const;
12986 
12990  bool operator==(TextAttributeKit const & in_kit) const;
12991 
12995  bool operator!=(TextAttributeKit const & in_kit) const;
12996 
12997 
13004 
13009  TextAttributeKit & SetBold(bool in_state);
13010 
13015  TextAttributeKit & SetItalic(bool in_state);
13016 
13020  TextAttributeKit & SetOverline(bool in_state);
13021 
13025  TextAttributeKit & SetStrikethrough(bool in_state);
13026 
13030  TextAttributeKit & SetUnderline(bool in_state);
13031 
13037  TextAttributeKit & SetSlant(float in_angle);
13038 
13043  TextAttributeKit & SetLineSpacing(float in_multiplier);
13044 
13049  TextAttributeKit & SetRotation(Text::Rotation in_state, float in_angle = 0.0f);
13050 
13055  TextAttributeKit & SetRotation(float in_angle);
13056 
13062  TextAttributeKit & SetExtraSpace(bool in_state, float in_size = 0.0f, Text::SizeUnits in_units = Text::SizeUnits::ObjectSpace);
13063 
13069  TextAttributeKit & SetExtraSpace(float in_size, Text::SizeUnits in_units);
13070 
13077  TextAttributeKit & SetGreeking(bool in_state, float in_size = 0.0f, Text::GreekingUnits in_units = Text::GreekingUnits::ObjectSpace, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
13078 
13085 
13095  TextAttributeKit & SetSizeTolerance(bool in_state, float in_size = 50.0f, Text::SizeToleranceUnits in_units = Text::SizeToleranceUnits::Percent);
13096 
13106  TextAttributeKit & SetSizeTolerance(float in_size, Text::SizeToleranceUnits in_units);
13107 
13112  TextAttributeKit & SetSize(float in_size, Text::SizeUnits in_units);
13113 
13120  TextAttributeKit & SetFont(char const * in_name);
13121 
13125  TextAttributeKit & SetTransform(Text::Transform in_trans);
13126 
13130  TextAttributeKit & SetRenderer(Text::Renderer in_rend);
13131 
13136  TextAttributeKit & SetPreference(Text::Preference in_pref);
13137 
13145  TextAttributeKit & SetPreference(float in_cutoff, Text::SizeUnits in_units, Text::Preference in_smaller, Text::Preference in_larger);
13146 
13151  TextAttributeKit & SetPath(Vector const & in_path);
13152 
13160  TextAttributeKit & SetSpacing(float in_multiplier);
13161 
13162 
13165  TextAttributeKit & UnsetAlignment();
13166 
13169  TextAttributeKit & UnsetBold();
13170 
13173  TextAttributeKit & UnsetItalic();
13174 
13177  TextAttributeKit & UnsetOverline();
13178 
13181  TextAttributeKit & UnsetStrikethrough();
13182 
13185  TextAttributeKit & UnsetUnderline();
13186 
13189  TextAttributeKit & UnsetSlant();
13190 
13193  TextAttributeKit & UnsetLineSpacing();
13194 
13197  TextAttributeKit & UnsetRotation();
13198 
13201  TextAttributeKit & UnsetExtraSpace();
13202 
13205  TextAttributeKit & UnsetGreeking();
13206 
13209  TextAttributeKit & UnsetSizeTolerance();
13210 
13213  TextAttributeKit & UnsetSize();
13214 
13217  TextAttributeKit & UnsetFont();
13218 
13221  TextAttributeKit & UnsetTransform();
13222 
13225  TextAttributeKit & UnsetRenderer();
13226 
13229  TextAttributeKit & UnsetPreference();
13230 
13233  TextAttributeKit & UnsetPath();
13234 
13237  TextAttributeKit & UnsetSpacing();
13238 
13241  TextAttributeKit & UnsetEverything();
13242 
13243 
13249  bool ShowAlignment(Text::Alignment & out_align, Text::ReferenceFrame & out_ref, Text::Justification & out_justify) const;
13250 
13254  bool ShowBold(bool & out_state) const;
13255 
13259  bool ShowItalic(bool & out_state) const;
13260 
13264  bool ShowOverline(bool & out_state) const;
13265 
13269  bool ShowStrikethrough(bool & out_state) const;
13270 
13274  bool ShowUnderline(bool & out_state) const;
13275 
13279  bool ShowSlant(float & out_angle) const;
13280 
13284  bool ShowLineSpacing(float & out_multiplier) const;
13285 
13290  bool ShowRotation(Text::Rotation & out_rot, float & out_angle) const;
13291 
13297  bool ShowExtraSpace(bool & out_state, float & out_size, Text::SizeUnits & out_units) const;
13298 
13305  bool ShowGreeking(bool & out_state, float & out_size, Text::GreekingUnits & out_units, Text::GreekingMode & out_mode) const;
13306 
13312  bool ShowSizeTolerance(bool & out_state, float & out_size, Text::SizeToleranceUnits & out_units) const;
13313 
13318  bool ShowSize(float & out_size, Text::SizeUnits & out_units) const;
13319 
13323  bool ShowFont(UTF8 & out_name) const;
13324 
13328  bool ShowTransform(Text::Transform & out_trans) const;
13329 
13333  bool ShowRenderer(Text::Renderer & out_rend) const;
13334 
13341  bool ShowPreference(float & out_cutoff, Text::SizeUnits & out_units, Text::Preference & out_smaller, Text::Preference & out_larger) const;
13342 
13346  bool ShowPath(Vector & out_path) const;
13347 
13351  bool ShowSpacing(float & out_multiplier) const;
13352 };
13353 
13359 class HPS_API TextAttributeControl : public Control
13360 {
13361 public:
13362 
13364  explicit TextAttributeControl(SegmentKey & in_seg);
13365 
13367  TextAttributeControl(TextAttributeControl const & in_that);
13368 
13373 
13377  TextAttributeControl & operator=(TextAttributeControl && in_that);
13378 
13381 
13382  HPS::Type ObjectType() const {return HPS::Type::TextAttributeControl;};
13383 
13387  TextAttributeControl & operator=(TextAttributeControl const & in_that);
13388 
13395 
13400  TextAttributeControl & SetBold(bool in_state);
13401 
13406  TextAttributeControl & SetItalic(bool in_state);
13407 
13411  TextAttributeControl & SetOverline(bool in_state);
13412 
13416  TextAttributeControl & SetStrikethrough(bool in_state);
13417 
13421  TextAttributeControl & SetUnderline(bool in_state);
13422 
13428  TextAttributeControl & SetSlant(float in_angle);
13429 
13434  TextAttributeControl & SetLineSpacing(float in_multiplier);
13435 
13440  TextAttributeControl & SetRotation(Text::Rotation in_state, float in_angle = 0.0f);
13441 
13446  TextAttributeControl & SetRotation(float in_angle);
13447 
13453  TextAttributeControl & SetExtraSpace(bool in_state, float in_size = 0.0f, Text::SizeUnits in_units = Text::SizeUnits::ObjectSpace);
13454 
13460  TextAttributeControl & SetExtraSpace(float in_size, Text::SizeUnits in_units);
13461 
13468  TextAttributeControl & SetGreeking(bool in_state, float in_size = 0.0f, Text::GreekingUnits in_units = Text::GreekingUnits::ObjectSpace, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
13469 
13476 
13486  TextAttributeControl & SetSizeTolerance(bool in_state, float in_size = 50.0f, Text::SizeToleranceUnits in_units = Text::SizeToleranceUnits::Percent);
13487 
13497  TextAttributeControl & SetSizeTolerance(float in_size, Text::SizeToleranceUnits in_units);
13498 
13503  TextAttributeControl & SetSize(float in_size, Text::SizeUnits in_units);
13504 
13511  TextAttributeControl & SetFont(char const * in_name);
13512 
13516  TextAttributeControl & SetTransform(Text::Transform in_trans);
13517 
13521  TextAttributeControl & SetRenderer(Text::Renderer in_rend);
13522 
13527  TextAttributeControl & SetPreference(Text::Preference in_pref);
13528 
13536  TextAttributeControl & SetPreference(float in_cutoff, Text::SizeUnits in_units, Text::Preference in_smaller, Text::Preference in_larger);
13537 
13542  TextAttributeControl & SetPath(Vector const & in_path);
13543 
13551  TextAttributeControl & SetSpacing(float in_multiplier);
13552 
13553 
13556  TextAttributeControl & UnsetAlignment();
13557 
13560  TextAttributeControl & UnsetBold();
13561 
13564  TextAttributeControl & UnsetItalic();
13565 
13568  TextAttributeControl & UnsetOverline();
13569 
13572  TextAttributeControl & UnsetStrikethrough();
13573 
13576  TextAttributeControl & UnsetUnderline();
13577 
13580  TextAttributeControl & UnsetSlant();
13581 
13584  TextAttributeControl & UnsetLineSpacing();
13585 
13588  TextAttributeControl & UnsetRotation();
13589 
13592  TextAttributeControl & UnsetExtraSpace();
13593 
13596  TextAttributeControl & UnsetGreeking();
13597 
13600  TextAttributeControl & UnsetSizeTolerance();
13601 
13604  TextAttributeControl & UnsetSize();
13605 
13608  TextAttributeControl & UnsetFont();
13609 
13612  TextAttributeControl & UnsetTransform();
13613 
13616  TextAttributeControl & UnsetRenderer();
13617 
13620  TextAttributeControl & UnsetPreference();
13621 
13624  TextAttributeControl & UnsetPath();
13625 
13628  TextAttributeControl & UnsetSpacing();
13629 
13632  TextAttributeControl & UnsetEverything();
13633 
13634 
13640  bool ShowAlignment(Text::Alignment & out_align, Text::ReferenceFrame & out_ref, Text::Justification & out_justify) const;
13641 
13645  bool ShowBold(bool & out_state) const;
13646 
13650  bool ShowItalic(bool & out_state) const;
13651 
13655  bool ShowOverline(bool & out_state) const;
13656 
13660  bool ShowStrikethrough(bool & out_state) const;
13661 
13665  bool ShowUnderline(bool & out_state) const;
13666 
13670  bool ShowSlant(float & out_angle) const;
13671 
13675  bool ShowLineSpacing(float & out_multiplier) const;
13676 
13681  bool ShowRotation(Text::Rotation & out_rot, float & out_angle) const;
13682 
13688  bool ShowExtraSpace(bool & out_state, float & out_size, Text::SizeUnits & out_units) const;
13689 
13696  bool ShowGreeking(bool & out_state, float & out_size, Text::GreekingUnits & out_units, Text::GreekingMode & out_mode) const;
13697 
13703  bool ShowSizeTolerance(bool & out_state, float & out_size, Text::SizeToleranceUnits & out_units) const;
13704 
13709  bool ShowSize(float & out_size, Text::SizeUnits & out_units) const;
13710 
13714  bool ShowFont(UTF8 & out_name) const;
13715 
13719  bool ShowTransform(Text::Transform & out_trans) const;
13720 
13724  bool ShowRenderer(Text::Renderer & out_rend) const;
13725 
13732  bool ShowPreference(float & out_cutoff, Text::SizeUnits & out_units, Text::Preference & out_smaller, Text::Preference & out_larger) const;
13733 
13737  bool ShowPath(Vector & out_path) const;
13738 
13742  bool ShowSpacing(float & out_multiplier) const;
13743 
13744 private:
13747 };
13748 
13749 
13750 
13751 
13752 
13754 class HPS_API LineAttributeKit : public Object
13755 {
13756 public:
13757 
13759  LineAttributeKit();
13760 
13763  LineAttributeKit(LineAttributeKit const & in_kit);
13764 
13768  LineAttributeKit(LineAttributeKit && in_that);
13769 
13773  LineAttributeKit & operator=(LineAttributeKit && in_that);
13774 
13776  virtual ~LineAttributeKit();
13777 
13778  HPS::Type ObjectType() const {return HPS::Type::LineAttributeKit;};
13779 
13783  static LineAttributeKit GetDefault();
13784 
13787  void Set(LineAttributeKit const & in_kit);
13788 
13791  void Show(LineAttributeKit & out_kit) const;
13792 
13796  LineAttributeKit & operator=(LineAttributeKit const & in_kit);
13797 
13800  bool Empty() const;
13801 
13805  bool Equals(LineAttributeKit const & in_kit) const;
13806 
13810  bool operator==(LineAttributeKit const & in_kit) const;
13811 
13815  bool operator!=(LineAttributeKit const & in_kit) const;
13816 
13817 
13821  LineAttributeKit & SetPattern(char const * in_name);
13822 
13827  LineAttributeKit & SetPattern(char const * in_name, LinePatternOptionsKit const & in_options);
13828 
13833  LineAttributeKit & SetWeight(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
13834 
13835 
13838  LineAttributeKit & UnsetPattern();
13839 
13842  LineAttributeKit & UnsetWeight();
13843 
13846  LineAttributeKit & UnsetEverything();
13847 
13848 
13853  bool ShowPattern(UTF8 & out_pattern, LinePatternOptionsKit & out_options) const;
13854 
13859  bool ShowWeight(float & out_weight, Line::SizeUnits & out_units) const;
13860 };
13861 
13867 class HPS_API LineAttributeControl : public Control
13868 {
13869 public:
13870 
13872  explicit LineAttributeControl(SegmentKey & in_seg);
13873 
13875  LineAttributeControl(LineAttributeControl const & in_that);
13876 
13881 
13885  LineAttributeControl & operator=(LineAttributeControl && in_that);
13886 
13889 
13890  HPS::Type ObjectType() const {return HPS::Type::LineAttributeControl;};
13891 
13895  LineAttributeControl & operator=(LineAttributeControl const & in_that);
13896 
13900  LineAttributeControl & SetPattern(char const * in_pattern);
13901 
13906  LineAttributeControl & SetPattern(char const * in_pattern, LinePatternOptionsKit const & in_options);
13907 
13912  LineAttributeControl & SetWeight(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
13913 
13914 
13917  LineAttributeControl & UnsetPattern();
13918 
13921  LineAttributeControl & UnsetWeight();
13922 
13925  LineAttributeControl & UnsetEverything();
13926 
13927 
13932  bool ShowPattern(UTF8 & out_pattern, LinePatternOptionsKit & out_options) const;
13933 
13938  bool ShowWeight(float & out_weight, Line::SizeUnits & out_units) const;
13939 
13940 private:
13943 };
13944 
13945 
13946 
13948 class HPS_API EdgeAttributeKit : public Object
13949 {
13950 public:
13951 
13953  EdgeAttributeKit();
13954 
13957  EdgeAttributeKit(EdgeAttributeKit const & in_kit);
13958 
13962  EdgeAttributeKit(EdgeAttributeKit && in_that);
13963 
13967  EdgeAttributeKit & operator=(EdgeAttributeKit && in_that);
13968 
13970  virtual ~EdgeAttributeKit();
13971 
13972  HPS::Type ObjectType() const {return HPS::Type::EdgeAttributeKit;};
13973 
13977  static EdgeAttributeKit GetDefault();
13978 
13981  void Set(EdgeAttributeKit const & in_kit);
13982 
13985  void Show(EdgeAttributeKit & out_kit) const;
13986 
13990  EdgeAttributeKit & operator=(EdgeAttributeKit const & in_kit);
13991 
13994  bool Empty() const;
13995 
13999  bool Equals(EdgeAttributeKit const & in_kit) const;
14000 
14004  bool operator==(EdgeAttributeKit const & in_kit) const;
14005 
14009  bool operator!=(EdgeAttributeKit const & in_kit) const;
14010 
14011 
14015  EdgeAttributeKit & SetPattern(char const * in_pattern_name);
14016 
14021  EdgeAttributeKit & SetWeight(float in_weight, Edge::SizeUnits in_units = Edge::SizeUnits::ScaleFactor);
14022 
14023 
14026  EdgeAttributeKit & UnsetPattern();
14027 
14030  EdgeAttributeKit & UnsetWeight();
14031 
14034  EdgeAttributeKit & UnsetEverything();
14035 
14036 
14040  bool ShowPattern(UTF8 & out_pattern_name) const;
14041 
14046  bool ShowWeight(float & out_weight, Edge::SizeUnits & out_units) const;
14047 };
14048 
14054 class HPS_API EdgeAttributeControl : public Control
14055 {
14056 public:
14057 
14059  explicit EdgeAttributeControl(SegmentKey & in_seg);
14060 
14062  EdgeAttributeControl(EdgeAttributeControl const & in_that);
14063 
14068 
14072  EdgeAttributeControl & operator=(EdgeAttributeControl && in_that);
14073 
14076 
14077  HPS::Type ObjectType() const {return HPS::Type::EdgeAttributeControl;};
14078 
14082  EdgeAttributeControl & operator=(EdgeAttributeControl const & in_that);
14083 
14087  EdgeAttributeControl & SetPattern(char const * in_pattern_name);
14088 
14093  EdgeAttributeControl & SetWeight(float in_weight, Edge::SizeUnits in_units = Edge::SizeUnits::ScaleFactor);
14094 
14095 
14098  EdgeAttributeControl & UnsetPattern();
14099 
14102  EdgeAttributeControl & UnsetWeight();
14103 
14106  EdgeAttributeControl & UnsetEverything();
14107 
14108 
14112  bool ShowPattern(UTF8 & out_pattern_name) const;
14113 
14118  bool ShowWeight(float & out_weight, Edge::SizeUnits & out_units) const;
14119 
14120 private:
14123 };
14124 
14125 
14127 class HPS_API CurveAttributeKit : public Object
14128 {
14129 public:
14130 
14133 
14136  CurveAttributeKit(CurveAttributeKit const & in_kit);
14137 
14142 
14146  CurveAttributeKit & operator=(CurveAttributeKit && in_that);
14147 
14149  virtual ~CurveAttributeKit();
14150 
14151  HPS::Type ObjectType() const {return HPS::Type::CurveAttributeKit;};
14152 
14156  static CurveAttributeKit GetDefault();
14157 
14160  void Set(CurveAttributeKit const & in_kit);
14161 
14164  void Show(CurveAttributeKit & out_kit) const;
14165 
14169  CurveAttributeKit & operator=(CurveAttributeKit const & in_kit);
14170 
14173  bool Empty() const;
14174 
14178  bool Equals(CurveAttributeKit const & in_kit) const;
14179 
14183  bool operator==(CurveAttributeKit const & in_kit) const;
14184 
14188  bool operator!=(CurveAttributeKit const & in_kit) const;
14189 
14190  //Set
14191  CurveAttributeKit & SetBudget(size_t in_budget);
14192 
14199  CurveAttributeKit & SetContinuedBudget(bool in_state, size_t in_budget = 0);
14200 
14207  CurveAttributeKit & SetContinuedBudget(size_t in_budget);
14208 
14209 
14216  CurveAttributeKit & SetViewDependent(bool in_state);
14217 
14221  CurveAttributeKit & SetMaximumDeviation(float in_deviation);
14222 
14227  CurveAttributeKit & SetMaximumAngle(float in_degrees);
14228 
14233  CurveAttributeKit & SetMaximumLength(float in_length);
14234 
14235 
14238  CurveAttributeKit & UnsetBudget();
14239 
14242  CurveAttributeKit & UnsetContinuedBudget();
14243 
14246  CurveAttributeKit & UnsetViewDependent();
14247 
14250  CurveAttributeKit & UnsetMaximumDeviation();
14251 
14254  CurveAttributeKit & UnsetMaximumAngle();
14255 
14258  CurveAttributeKit & UnsetMaximumLength();
14259 
14262  CurveAttributeKit & UnsetEverything();
14263 
14264 
14268  bool ShowBudget(size_t & out_budget) const;
14269 
14274  bool ShowContinuedBudget(bool & out_state, size_t & out_budget) const;
14275 
14279  bool ShowViewDependent(bool & out_state) const;
14280 
14285  bool ShowMaximumDeviation(float & out_deviation) const;
14286 
14291  bool ShowMaximumAngle(float & out_degrees) const;
14292 
14297  bool ShowMaximumLength(float & out_length) const;
14298 };
14299 
14300 
14304 class HPS_API CurveAttributeControl : public Control
14305 {
14306 public:
14307 
14309  explicit CurveAttributeControl(SegmentKey & in_seg);
14310 
14313 
14318 
14322  CurveAttributeControl & operator=(CurveAttributeControl && in_that);
14323 
14326 
14327  HPS::Type ObjectType() const {return HPS::Type::CurveAttributeControl;};
14328 
14332  CurveAttributeControl & operator=(CurveAttributeControl const & in_that);
14333 
14337  CurveAttributeControl & SetBudget(size_t in_budget);
14338 
14345  CurveAttributeControl & SetContinuedBudget(bool in_state, size_t in_budget = 0);
14346 
14353  CurveAttributeControl & SetContinuedBudget(size_t in_budget);
14354 
14361  CurveAttributeControl & SetViewDependent(bool in_state);
14362 
14366  CurveAttributeControl & SetMaximumDeviation(float in_deviation);
14367 
14372  CurveAttributeControl & SetMaximumAngle(float in_degrees);
14373 
14378  CurveAttributeControl & SetMaximumLength(float in_length);
14379 
14380 
14383  CurveAttributeControl & UnsetBudget();
14384 
14387  CurveAttributeControl & UnsetContinuedBudget();
14388 
14391  CurveAttributeControl & UnsetViewDependent();
14392 
14395  CurveAttributeControl & UnsetMaximumDeviation();
14396 
14399  CurveAttributeControl & UnsetMaximumAngle();
14400 
14403  CurveAttributeControl & UnsetMaximumLength();
14404 
14407  CurveAttributeControl & UnsetEverything();
14408 
14409 
14413  bool ShowBudget(size_t & out_budget) const;
14414 
14419  bool ShowContinuedBudget(bool & out_state, size_t & out_budget) const;
14420 
14424  bool ShowViewDependent(bool & out_state) const;
14425 
14430  bool ShowMaximumDeviation(float & out_deviation) const;
14431 
14436  bool ShowMaximumAngle(float & out_degrees) const;
14437 
14442  bool ShowMaximumLength(float & out_length) const;
14443 
14444 private:
14447 };
14448 
14449 
14450 
14451 
14453 class HPS_API MatrixKit : public Object
14454 {
14455 public:
14456 
14458  MatrixKit();
14459 
14462  MatrixKit(MatrixKit const & in_kit);
14463 
14467  MatrixKit(MatrixKit && in_that);
14468 
14472  MatrixKit & operator=(MatrixKit && in_that);
14473 
14477  MatrixKit(FloatArray const & in_matrix_source);
14478 
14482  MatrixKit(float const in_matrix_source []);
14483 
14486  MatrixKit(Quaternion const & in_quaternion); //implicit conversion from quaternion
14487 
14489  virtual ~MatrixKit();
14490 
14491  HPS::Type ObjectType() const {return HPS::Type::MatrixKit;};
14492 
14495  static MatrixKit GetDefault();
14496 
14499  void Set(MatrixKit const & in_kit);
14500 
14503  void Show(MatrixKit & out_kit) const;
14504 
14508  MatrixKit & operator=(MatrixKit const & in_kit);
14509 
14512  bool Empty() const;
14513 
14517  bool Equals(MatrixKit const & in_kit) const;
14518 
14522  bool operator==(MatrixKit const & in_kit) const;
14523 
14527  bool operator!=(MatrixKit const & in_kit) const;
14528 
14534  MatrixKit & SetElement(size_t in_row, size_t in_column, float in_value);
14535 
14540  MatrixKit & SetElement(size_t in_ordinal_zero_to_fifteen, float in_value);
14541 
14545  MatrixKit & SetElements(FloatArray const & in_values);
14546 
14551  MatrixKit & SetElements(size_t in_value_count, float const in_values []);
14552 
14553 
14556  MatrixKit & UnsetEverything();
14557 
14558 
14564  bool ShowElement(size_t in_row, size_t in_column, float & out_value) const;
14565 
14570  bool ShowElement(size_t in_ordinal_zero_to_fifteen, float & out_value) const;
14571 
14575  bool ShowElements(FloatArray & out_matrix) const;
14576 
14580  bool ShowDeterminant(float & out_determinant) const;
14581 
14585  bool ShowInverse(MatrixKit & out_matrix) const;
14586 
14591  bool ShowAdjoint(MatrixKit & out_matrix) const;
14592 
14593 
14599  MatrixKit & Rotate(float in_x, float in_y, float in_z);
14600 
14605  MatrixKit & RotateOffAxis(Vector const & in_vector, float in_theta);
14606 
14612  MatrixKit & Translate(float in_x, float in_y, float in_z);
14613 
14619  MatrixKit & Scale(float in_x, float in_y, float in_z);
14620 
14624  MatrixKit & Concatenate(MatrixKit const & in_kit);
14625 
14628  MatrixKit & Normalize();
14629 
14632  MatrixKit & Invert();
14633 
14637  MatrixKit & Adjoint();
14638 
14639 
14643  MatrixKit Multiply(MatrixKit const & in_right) const;
14644 
14648  MatrixKit const & MultiplyAndAssign(MatrixKit const & in_right);
14649 
14653  MatrixKit Multiply(float in_scalar) const;
14654 
14658  MatrixKit const & MultiplyAndAssign(float in_scalar);
14659 
14663  MatrixKit operator*(MatrixKit const & in_right) const;
14664 
14668  MatrixKit const & operator*=(MatrixKit const & in_right);
14669 
14673  MatrixKit operator*(float in_scalar) const;
14674 
14678  MatrixKit const & operator*=(float in_scalar);
14679 
14680 
14684  Point Transform(Point const & in_source) const;
14685 
14689  PointArray Transform(PointArray const & in_source) const;
14690 
14695  PointArray Transform(size_t in_count, Point const in_source []) const;
14696 
14700  Vector Transform(Vector const & in_source) const;
14701 
14705  VectorArray Transform(VectorArray const & in_source) const;
14706 
14711  VectorArray Transform(size_t in_count, Vector const in_source []) const;
14712 
14716  Plane Transform(Plane const & in_source) const;
14717 
14721  PlaneArray Transform(PlaneArray const & in_source) const;
14722 
14727  PlaneArray Transform(size_t in_count, Plane const in_source []) const;
14728 
14732  SimpleCuboid Transform(SimpleCuboid const & in_source) const;
14733 
14737  SimpleSphere Transform(SimpleSphere const & in_source) const;
14738 };
14739 
14743 class HPS_API ModellingMatrixControl : public Control
14744 {
14745 public:
14746 
14748  explicit ModellingMatrixControl(SegmentKey const & in_seg);
14749 
14751  explicit ModellingMatrixControl(ReferenceKey const & in_ref);
14752 
14755 
14760 
14764  ModellingMatrixControl & operator=(ModellingMatrixControl && in_that);
14765 
14768 
14769  HPS::Type ObjectType() const {return HPS::Type::ModellingMatrixControl;};
14770 
14774  ModellingMatrixControl & operator=(ModellingMatrixControl const & in_that);
14775 
14781  ModellingMatrixControl & SetElement(size_t in_row, size_t in_column, float in_value);
14782 
14787  ModellingMatrixControl & SetElement(size_t in_ordinal_zero_to_fifteen, float in_value);
14788 
14792  ModellingMatrixControl & SetElements(FloatArray const & in_values);
14793 
14798  ModellingMatrixControl & SetElements(size_t in_value_count, float const in_values []);
14799 
14800 
14803  ModellingMatrixControl & UnsetEverything();
14804 
14805 
14811  bool ShowElement(size_t in_row, size_t in_column, float & out_value) const;
14812 
14817  bool ShowElement(size_t in_ordinal_zero_to_fifteen, float & out_value) const;
14818 
14822  bool ShowElements(FloatArray & out_matrix) const;
14823 
14827  bool ShowDeterminant(float & out_determinant) const;
14828 
14832  bool ShowInverse(MatrixKit & out_matrix) const;
14833 
14838  bool ShowAdjoint(MatrixKit & out_matrix) const;
14839 
14845  ModellingMatrixControl & Rotate(float in_x, float in_y, float in_z);
14846 
14851  ModellingMatrixControl & RotateOffAxis(Vector const & in_vector, float in_theta);
14852 
14858  ModellingMatrixControl & Translate(float in_x, float in_y, float in_z);
14859 
14865  ModellingMatrixControl & Scale(float in_x, float in_y, float in_z);
14866 
14870  ModellingMatrixControl & Concatenate(MatrixKit const & in_kit);
14871 
14874  ModellingMatrixControl & Normalize();
14875 
14878  ModellingMatrixControl & Invert();
14879 
14883  ModellingMatrixControl & Adjoint();
14884 
14885 private:
14888 };
14889 
14892 class HPS_API TextureMatrixControl : public Control
14893 {
14894 public:
14895 
14897  explicit TextureMatrixControl(SegmentKey & in_seg);
14898 
14900  TextureMatrixControl(const TextureMatrixControl & in_that);
14901 
14906 
14910  TextureMatrixControl & operator=(TextureMatrixControl && in_that);
14911 
14914 
14915  HPS::Type ObjectType() const {return HPS::Type::TextureMatrixControl;};
14916 
14920  TextureMatrixControl & operator=(TextureMatrixControl const & in_that);
14921 
14927  TextureMatrixControl & SetElement(size_t in_row, size_t in_column, float in_value);
14928 
14933  TextureMatrixControl & SetElement(size_t in_ordinal_zero_to_fifteen, float in_value);
14934 
14938  TextureMatrixControl & SetElements(FloatArray const & in_values);
14939 
14944  TextureMatrixControl & SetElements(size_t in_value_count, float const in_values []);
14945 
14946 
14949  TextureMatrixControl & UnsetEverything();
14950 
14951 
14957  bool ShowElement(size_t in_row, size_t in_column, float & out_value) const;
14958 
14963  bool ShowElement(size_t in_ordinal_zero_to_fifteen, float & out_value) const;
14964 
14968  bool ShowElements(FloatArray & out_matrix) const;
14969 
14973  bool ShowDeterminant(float & out_determinant) const;
14974 
14978  bool ShowInverse(MatrixKit & out_matrix) const;
14979 
14984  bool ShowAdjoint(MatrixKit & out_matrix) const;
14985 
14991  TextureMatrixControl & Rotate(float in_x, float in_y, float in_z);
14992 
14997  TextureMatrixControl & RotateOffAxis(Vector const & in_vector, float in_theta);
14998 
15004  TextureMatrixControl & Translate(float in_x, float in_y, float in_z);
15005 
15011  TextureMatrixControl & Scale(float in_x, float in_y, float in_z);
15012 
15016  TextureMatrixControl & Concatenate(MatrixKit const & in_kit);
15017 
15020  TextureMatrixControl & Normalize();
15021 
15024  TextureMatrixControl & Invert();
15025 
15029  TextureMatrixControl & Adjoint();
15030 
15031 private:
15034 };
15035 
15036 
15039 class HPS_API MaterialMappingKit : public Object
15040 {
15041 public:
15042 
15045 
15048  MaterialMappingKit(MaterialMappingKit const & in_kit);
15049 
15054 
15058  MaterialMappingKit & operator=(MaterialMappingKit && in_that);
15059 
15061  ~MaterialMappingKit();
15062 
15063  HPS::Type ObjectType() const {return HPS::Type::MaterialMappingKit;};
15064 
15068  static MaterialMappingKit GetDefault();
15069 
15072  void Set(MaterialMappingKit const & in_kit);
15073 
15076  void Show(MaterialMappingKit & out_kit) const;
15077 
15081  MaterialMappingKit & operator=(MaterialMappingKit const & in_kit);
15082 
15085  bool Empty() const;
15086 
15090  bool Equals(MaterialMappingKit const & in_kit) const;
15091 
15095  bool operator==(MaterialMappingKit const & in_kit) const;
15096 
15100  bool operator!=(MaterialMappingKit const & in_kit) const;
15101 
15102  //Set
15103 
15107  MaterialMappingKit & SetAmbientLightUpColor(RGBAColor const & in_rgba_color);
15108 
15114  MaterialMappingKit & SetAmbientLightUpMaterialByIndex(float in_material_index);
15115 
15116 
15120  MaterialMappingKit & SetAmbientLightDownColor(RGBAColor const & in_rgba_color);
15121 
15127  MaterialMappingKit & SetAmbientLightDownMaterialByIndex(float in_material_index);
15128 
15134  MaterialMappingKit & SetBackFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15135 
15140  MaterialMappingKit & SetBackFaceAlpha(float in_alpha);
15141 
15148  MaterialMappingKit & SetBackFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15149 
15158  MaterialMappingKit & SetBackFaceModulatedTexture(char const * in_texture_name, RGBAColor const & in_modulating_color, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15159 
15163  MaterialMappingKit & SetBackFaceGloss(float in_value);
15164 
15168  MaterialMappingKit & SetBackFaceMaterial(MaterialKit const & in_material);
15169 
15174  MaterialMappingKit & SetBackFaceMaterialByIndex(float in_material_index);
15175 
15181  MaterialMappingKit & SetFrontFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15182 
15187  MaterialMappingKit & SetFrontFaceAlpha(float in_alpha);
15188 
15195  MaterialMappingKit & SetFrontFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15196 
15205  MaterialMappingKit & SetFrontFaceModulatedTexture(char const * in_texture_name, RGBAColor const & in_modulating_color, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15206 
15210  MaterialMappingKit & SetFrontFaceGloss(float in_value);
15211 
15215  MaterialMappingKit & SetFrontFaceMaterial(MaterialKit const & in_material);
15216 
15221  MaterialMappingKit & SetFrontFaceMaterialByIndex(float in_material_index);
15222 
15223 
15227  MaterialMappingKit & SetCutEdgeColor(RGBAColor const & in_rgba_color);
15228 
15234  MaterialMappingKit & SetCutEdgeMaterialByIndex(float in_material_index);
15235 
15241  MaterialMappingKit & SetCutFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15242 
15247  MaterialMappingKit & SetCutFaceAlpha(float in_alpha);
15248 
15255  MaterialMappingKit & SetCutFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15256 
15265  MaterialMappingKit & SetCutFaceModulatedTexture(char const * in_texture_name, RGBAColor const & in_modulating_color, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15266 
15270  MaterialMappingKit & SetCutFaceGloss(float in_value);
15271 
15275  MaterialMappingKit & SetCutFaceMaterial(MaterialKit const & in_material);
15276 
15281  MaterialMappingKit & SetCutFaceMaterialByIndex(float in_material_index);
15282 
15287  MaterialMappingKit & SetEdgeAlpha(float in_alpha);
15288 
15294  MaterialMappingKit & SetEdgeColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15295 
15302  MaterialMappingKit & SetEdgeTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15303 
15312  MaterialMappingKit & SetEdgeModulatedTexture(char const * in_texture_name, RGBAColor const & in_modulating_color, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15313 
15317  MaterialMappingKit & SetEdgeGloss(float in_value);
15318 
15322  MaterialMappingKit & SetEdgeMaterial(MaterialKit const & in_material);
15323 
15328  MaterialMappingKit & SetEdgeMaterialByIndex(float in_material_index);
15329 
15334  MaterialMappingKit & SetFaceAlpha(float in_alpha);
15335 
15341  MaterialMappingKit & SetFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15342 
15349  MaterialMappingKit & SetFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15350 
15359  MaterialMappingKit & SetFaceModulatedTexture(char const * in_texture_name, RGBAColor const & in_modulating_color, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15360 
15364  MaterialMappingKit & SetFaceGloss(float in_value);
15365 
15369  MaterialMappingKit & SetFaceMaterial(MaterialKit const & in_material);
15370 
15375  MaterialMappingKit & SetFaceMaterialByIndex(float in_material_index);
15376 
15380  MaterialMappingKit & SetFaceShader(char const * in_shader_name);
15381 
15382 
15383 
15384 
15385 
15389  MaterialMappingKit & SetLightColor(RGBAColor const & in_rgba_color);
15390 
15396  MaterialMappingKit & SetLightMaterialByIndex(float in_material_index);
15397 
15398 
15402  MaterialMappingKit & SetLineColor(RGBAColor const & in_rgba_color);
15403 
15409  MaterialMappingKit & SetLineMaterialByIndex(float in_material_index);
15410 
15411 
15415  MaterialMappingKit & SetMarkerColor(RGBAColor const & in_rgba_color);
15416 
15422  MaterialMappingKit & SetMarkerMaterialByIndex(float in_material_index);
15423 
15424 
15428  MaterialMappingKit & SetTextColor(RGBAColor const & in_rgba_color);
15429 
15435  MaterialMappingKit & SetTextMaterialByIndex(float in_material_index);
15436 
15441  MaterialMappingKit & SetVertexAlpha(float in_alpha);
15442 
15448  MaterialMappingKit & SetVertexColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15449 
15456  MaterialMappingKit & SetVertexTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15457 
15466  MaterialMappingKit & SetVertexModulatedTexture(char const * in_texture_name, RGBAColor const & in_modulating_color, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15467 
15471  MaterialMappingKit & SetVertexGloss(float in_value);
15472 
15476  MaterialMappingKit & SetVertexMaterial(MaterialKit const & in_material);
15477 
15482  MaterialMappingKit & SetVertexMaterialByIndex(float in_material_index);
15483 
15487  MaterialMappingKit & SetVertexShader(char const * in_shader_name);
15488 
15489 
15493  MaterialMappingKit & SetWindowColor(RGBAColor const & in_rgba_color);
15494 
15500  MaterialMappingKit & SetWindowMaterialByIndex(float in_material_index);
15501 
15502 
15506  MaterialMappingKit & SetWindowContrastColor(RGBAColor const & in_rgba_color);
15507 
15513  MaterialMappingKit & SetWindowContrastMaterialByIndex(float in_material_index);
15514 
15515  //Aggregate Sets
15516 
15520  MaterialMappingKit & SetCutGeometryColor(RGBAColor const & in_rgba_color);
15521 
15526  MaterialMappingKit & SetCutGeometryMaterialByIndex(float in_color_index);
15527 
15528 
15532  MaterialMappingKit & SetAmbientLightColor(RGBAColor const & in_rgba_color);
15533 
15539  MaterialMappingKit & SetAmbientLightMaterialByIndex(float in_material_index);
15540 
15541 
15542  //Unset
15543 
15546  MaterialMappingKit & UnsetAmbientLightUpColor();
15547 
15548 
15551  MaterialMappingKit & UnsetAmbientLightDownColor();
15552 
15553 
15556  MaterialMappingKit & UnsetBackFaceMaterial();
15557 
15560  MaterialMappingKit & UnsetBackFaceChannel(Material::Channel in_channel);
15561 
15564  MaterialMappingKit & UnsetBackFaceChannel(Material::Channel in_channel, size_t in_layer);
15565 
15568  MaterialMappingKit & UnsetFrontFaceMaterial();
15569 
15572  MaterialMappingKit & UnsetFrontFaceChannel(Material::Channel in_channel);
15573 
15576  MaterialMappingKit & UnsetFrontFaceChannel(Material::Channel in_channel, size_t in_layer);
15577 
15578 
15579 
15582  MaterialMappingKit & UnsetCutEdgeColor();
15583 
15584 
15587  MaterialMappingKit & UnsetCutFaceMaterial();
15588 
15591  MaterialMappingKit & UnsetCutFaceChannel(Material::Channel in_channel);
15592 
15595  MaterialMappingKit & UnsetCutFaceChannel(Material::Channel in_channel, size_t in_layer);
15596 
15597 
15600  MaterialMappingKit & UnsetEdgeMaterial();
15601 
15604  MaterialMappingKit & UnsetEdgeChannel(Material::Channel in_channel);
15605 
15608  MaterialMappingKit & UnsetEdgeChannel(Material::Channel in_channel, size_t in_layer);
15609 
15610 
15613  MaterialMappingKit & UnsetFaceMaterial();
15614 
15617  MaterialMappingKit & UnsetFaceChannel(Material::Channel in_channel);
15618 
15621  MaterialMappingKit & UnsetFaceChannel(Material::Channel in_channel, size_t in_layer);
15622 
15623 
15626  MaterialMappingKit & UnsetLightColor();
15627 
15628 
15631  MaterialMappingKit & UnsetLineColor();
15632 
15633 
15636  MaterialMappingKit & UnsetMarkerColor();
15637 
15638 
15641  MaterialMappingKit & UnsetTextColor();
15642 
15643 
15646  MaterialMappingKit & UnsetVertexMaterial();
15647 
15650  MaterialMappingKit & UnsetVertexChannel(Material::Channel in_channel);
15651 
15654  MaterialMappingKit & UnsetVertexChannel(Material::Channel in_channel, size_t in_layer);
15655 
15656 
15659  MaterialMappingKit & UnsetWindowColor();
15660 
15661 
15664  MaterialMappingKit & UnsetWindowContrastColor();
15665 
15666 
15667  //Aggregate Unsets
15668 
15671  MaterialMappingKit & UnsetCutGeometryColor();
15672 
15675  MaterialMappingKit & UnsetAmbientLightColor();
15676 
15679  MaterialMappingKit & UnsetEverything();
15680 
15681 
15682  //Show
15683 
15689  bool ShowAmbientLightUpColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15690 
15696  bool ShowAmbientLightDownColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15697 
15698 
15706  bool ShowBackFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15707 
15716  bool ShowBackFaceChannel(Material::Channel in_channel, size_t in_layer, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15717 
15723  bool ShowBackFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
15724 
15725 
15733  bool ShowFrontFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15734 
15743  bool ShowFrontFaceChannel(Material::Channel in_channel, size_t in_layer, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15744 
15750  bool ShowFrontFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
15751 
15752 
15753 
15759  bool ShowCutEdgeColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15760 
15761 
15769  bool ShowCutFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15770 
15779  bool ShowCutFaceChannel(Material::Channel in_channel, size_t in_layer, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15780 
15786  bool ShowCutFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
15787 
15788 
15796  bool ShowEdgeChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15797 
15806  bool ShowEdgeChannel(Material::Channel in_channel, size_t in_layer, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15807 
15813  bool ShowEdgeMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
15814 
15815 
15823  bool ShowFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15824 
15833  bool ShowFaceChannel(Material::Channel in_channel, size_t in_layer, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15834 
15840  bool ShowFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
15841 
15842 
15848  bool ShowLightColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15849 
15850 
15856  bool ShowLineColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15857 
15858 
15864  bool ShowMarkerColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15865 
15866 
15872  bool ShowTextColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15873 
15874 
15882  bool ShowVertexChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15883 
15892  bool ShowVertexChannel(Material::Channel in_channel, size_t in_layer, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15893 
15899  bool ShowVertexMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
15900 
15901 
15907  bool ShowWindowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15908 
15909 
15915  bool ShowWindowContrastColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15916 };
15917 
15918 
15924 class HPS_API MaterialMappingControl : public Control
15925 {
15926 public:
15927 
15929  explicit MaterialMappingControl(SegmentKey & in_seg);
15930 
15933 
15938 
15942  MaterialMappingControl & operator=(MaterialMappingControl && in_that);
15943 
15946 
15947  HPS::Type ObjectType() const {return HPS::Type::MaterialMappingControl;};
15948 
15952  MaterialMappingControl & operator=(MaterialMappingControl const & in_that);
15953 
15954  //Set
15955 
15959  MaterialMappingControl & SetAmbientLightUpColor(RGBAColor const & in_rgba_color);
15960 
15966  MaterialMappingControl & SetAmbientLightUpMaterialByIndex(float in_material_index);
15967 
15968 
15972  MaterialMappingControl & SetAmbientLightDownColor(RGBAColor const & in_rgba_color);
15973 
15979  MaterialMappingControl & SetAmbientLightDownMaterialByIndex(float in_material_index);
15980 
15985  MaterialMappingControl & SetBackFaceAlpha(float in_alpha);
15986 
15992  MaterialMappingControl & SetBackFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15993 
16000  MaterialMappingControl & SetBackFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
16001 
16010  MaterialMappingControl & SetBackFaceModulatedTexture(char const * in_texture_name, RGBAColor const & in_modulating_color, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
16011 
16015  MaterialMappingControl & SetBackFaceGloss(float in_value);
16016 
16020  MaterialMappingControl & SetBackFaceMaterial(MaterialKit const & in_material);
16021 
16026  MaterialMappingControl & SetBackFaceMaterialByIndex(float in_material_index);
16027 
16028 
16033  MaterialMappingControl & SetFrontFaceAlpha(float in_alpha);
16034 
16040  MaterialMappingControl & SetFrontFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
16041 
16048  MaterialMappingControl & SetFrontFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
16049 
16058  MaterialMappingControl & SetFrontFaceModulatedTexture(char const * in_texture_name, RGBAColor const & in_modulating_color, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
16059 
16063  MaterialMappingControl & SetFrontFaceGloss(float in_value);
16064 
16068  MaterialMappingControl & SetFrontFaceMaterial(MaterialKit const & in_material);
16069 
16074  MaterialMappingControl & SetFrontFaceMaterialByIndex(float in_material_index);
16075 
16079  MaterialMappingControl & SetCutEdgeColor(RGBAColor const & in_rgba_color);
16080 
16086  MaterialMappingControl & SetCutEdgeMaterialByIndex(float in_material_index);
16087 
16092  MaterialMappingControl & SetCutFaceAlpha(float in_alpha);
16093 
16099  MaterialMappingControl & SetCutFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
16100 
16107  MaterialMappingControl & SetCutFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
16108 
16117  MaterialMappingControl & SetCutFaceModulatedTexture(char const * in_texture_name, RGBAColor const & in_modulating_color, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
16118 
16122  MaterialMappingControl & SetCutFaceGloss(float in_value);
16123 
16127  MaterialMappingControl & SetCutFaceMaterial(MaterialKit const & in_material);
16128 
16133  MaterialMappingControl & SetCutFaceMaterialByIndex(float in_material_index);
16134 
16139  MaterialMappingControl & SetEdgeAlpha(float in_alpha);
16140 
16146  MaterialMappingControl & SetEdgeColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
16147 
16154  MaterialMappingControl & SetEdgeTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
16155 
16164  MaterialMappingControl & SetEdgeModulatedTexture(char const * in_texture_name, RGBAColor const & in_modulating_color, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
16165 
16169  MaterialMappingControl & SetEdgeGloss(float in_value);
16170 
16174  MaterialMappingControl & SetEdgeMaterial(MaterialKit const & in_material);
16175 
16180  MaterialMappingControl & SetEdgeMaterialByIndex(float in_material_index);
16181 
16187  MaterialMappingControl & SetFaceAlpha(float in_alpha);
16188 
16195  MaterialMappingControl & SetFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
16196 
16203  MaterialMappingControl & SetFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
16204 
16213  MaterialMappingControl & SetFaceModulatedTexture(char const * in_texture_name, RGBAColor const & in_modulating_color, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
16214 
16218  MaterialMappingControl & SetFaceGloss(float in_value);
16219 
16223  MaterialMappingControl & SetFaceMaterial(MaterialKit const & in_material);
16224 
16229  MaterialMappingControl & SetFaceMaterialByIndex(float in_material_index);
16230 
16234  MaterialMappingControl & SetFaceShader(char const * in_shader_name);
16235 
16236 
16240  MaterialMappingControl & SetLightColor(RGBAColor const & in_rgba_color);
16241 
16247  MaterialMappingControl & SetLightMaterialByIndex(float in_material_index);
16248 
16249 
16253  MaterialMappingControl & SetLineColor(RGBAColor const & in_rgba_color);
16254 
16260  MaterialMappingControl & SetLineMaterialByIndex(float in_material_index);
16261 
16262 
16266  MaterialMappingControl & SetMarkerColor(RGBAColor const & in_rgba_color);
16267 
16273  MaterialMappingControl & SetMarkerMaterialByIndex(float in_material_index);
16274 
16275 
16279  MaterialMappingControl & SetTextColor(RGBAColor const & in_rgba_color);
16280 
16286  MaterialMappingControl & SetTextMaterialByIndex(float in_material_index);
16287 
16288 
16293  MaterialMappingControl & SetVertexAlpha(float in_alpha);
16294 
16295 
16301  MaterialMappingControl & SetVertexColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
16302 
16309  MaterialMappingControl & SetVertexTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
16310 
16319  MaterialMappingControl & SetVertexModulatedTexture(char const * in_texture_name, RGBAColor const & in_modulating_color, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
16320 
16324  MaterialMappingControl & SetVertexGloss(float in_value);
16325 
16329  MaterialMappingControl & SetVertexMaterial(MaterialKit const & in_material);
16330 
16335  MaterialMappingControl & SetVertexMaterialByIndex(float in_material_index);
16336 
16340  MaterialMappingControl & SetVertexShader(char const * in_shader_name);
16341 
16342 
16346  MaterialMappingControl & SetWindowColor(RGBAColor const & in_rgba_color);
16347 
16353  MaterialMappingControl & SetWindowMaterialByIndex(float in_material_index);
16354 
16355 
16359  MaterialMappingControl & SetWindowContrastColor(RGBAColor const & in_rgba_color);
16360 
16366  MaterialMappingControl & SetWindowContrastMaterialByIndex(float in_material_index);
16367 
16368  //Aggregate Sets
16369 
16373  MaterialMappingControl & SetCutGeometryColor(RGBAColor const & in_rgba_color);
16374 
16379  MaterialMappingControl & SetCutGeometryMaterialByIndex(float in_color_index);
16380 
16381 
16385  MaterialMappingControl & SetAmbientLightColor(RGBAColor const & in_rgba_color);
16386 
16392  MaterialMappingControl & SetAmbientLightMaterialByIndex(float in_material_index);
16393 
16394 
16395  //Unset
16396 
16399  MaterialMappingControl & UnsetAmbientLightUpColor();
16400 
16401 
16404  MaterialMappingControl & UnsetAmbientLightDownColor();
16405 
16406 
16409  MaterialMappingControl & UnsetFrontFaceMaterial();
16410 
16413  MaterialMappingControl & UnsetFrontFaceChannel(Material::Channel in_channel);
16414 
16417  MaterialMappingControl & UnsetFrontFaceChannel(Material::Channel in_channel, size_t in_layer);
16418 
16419 
16422  MaterialMappingControl & UnsetBackFaceMaterial();
16423 
16426  MaterialMappingControl & UnsetBackFaceChannel(Material::Channel in_channel);
16427 
16430  MaterialMappingControl & UnsetBackFaceChannel(Material::Channel in_channel, size_t in_layer);
16431 
16432 
16435  MaterialMappingControl & UnsetCutEdgeColor();
16436 
16437 
16440  MaterialMappingControl & UnsetCutFaceMaterial();
16441 
16444  MaterialMappingControl & UnsetCutFaceChannel(Material::Channel in_channel);
16445 
16448  MaterialMappingControl & UnsetCutFaceChannel(Material::Channel in_channel, size_t in_layer);
16449 
16450 
16453  MaterialMappingControl & UnsetEdgeMaterial();
16454 
16457  MaterialMappingControl & UnsetEdgeChannel(Material::Channel in_channel);
16458 
16461  MaterialMappingControl & UnsetEdgeChannel(Material::Channel in_channel, size_t in_layer);
16462 
16463 
16466  MaterialMappingControl & UnsetFaceMaterial();
16467 
16470  MaterialMappingControl & UnsetFaceChannel(Material::Channel in_channel);
16471 
16474  MaterialMappingControl & UnsetFaceChannel(Material::Channel in_channel, size_t in_layer);
16475 
16476 
16479  MaterialMappingControl & UnsetLightColor();
16480 
16481 
16484  MaterialMappingControl & UnsetLineColor();
16485 
16486 
16489  MaterialMappingControl & UnsetMarkerColor();
16490 
16491 
16494  MaterialMappingControl & UnsetTextColor();
16495 
16496 
16499  MaterialMappingControl & UnsetVertexMaterial();
16500 
16503  MaterialMappingControl & UnsetVertexChannel(Material::Channel in_channel);
16504 
16507  MaterialMappingControl & UnsetVertexChannel(Material::Channel in_channel, size_t in_layer);
16508 
16509 
16512  MaterialMappingControl & UnsetWindowColor();
16513 
16514 
16517  MaterialMappingControl & UnsetWindowContrastColor();
16518 
16519 
16520  //Aggregate Unsets
16521 
16524  MaterialMappingControl & UnsetCutGeometryColor();
16525 
16528  MaterialMappingControl & UnsetAmbientLightColor();
16529 
16532  MaterialMappingControl & UnsetEverything();
16533 
16534 
16535  //Show
16536 
16542  bool ShowAmbientLightUpColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16543 
16544 
16550  bool ShowAmbientLightDownColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16551 
16552 
16560  bool ShowBackFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16561 
16570  bool ShowBackFaceChannel(Material::Channel in_channel, size_t in_layer, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16571 
16577  bool ShowBackFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
16578 
16579 
16587  bool ShowFrontFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16588 
16597  bool ShowFrontFaceChannel(Material::Channel in_channel, size_t in_layer, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16598 
16604  bool ShowFrontFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
16605 
16606 
16612  bool ShowCutEdgeColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16613 
16614 
16622  bool ShowCutFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16623 
16632  bool ShowCutFaceChannel(Material::Channel in_channel, size_t in_layer, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16633 
16639  bool ShowCutFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
16640 
16641 
16649  bool ShowEdgeChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16650 
16659  bool ShowEdgeChannel(Material::Channel in_channel, size_t in_layer, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16660 
16666  bool ShowEdgeMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
16667 
16668 
16676  bool ShowFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16677 
16686  bool ShowFaceChannel(Material::Channel in_channel, size_t in_layer, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16687 
16693  bool ShowFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
16694 
16695 
16701  bool ShowLightColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16702 
16703 
16709  bool ShowLineColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16710 
16711 
16717  bool ShowMarkerColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16718 
16719 
16725  bool ShowTextColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16726 
16727 
16735  bool ShowVertexChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16736 
16745  bool ShowVertexChannel(Material::Channel in_channel, size_t in_layer, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16746 
16752  bool ShowVertexMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
16753 
16754 
16760  bool ShowWindowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16761 
16762 
16768  bool ShowWindowContrastColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16769 
16770 private:
16772 };
16773 
16774 
16777 class HPS_API PortfolioControl : public Control
16778 {
16779 public:
16781  explicit PortfolioControl(SegmentKey & in_seg);
16782 
16784  PortfolioControl(PortfolioControl const & in_that);
16785 
16789  PortfolioControl(PortfolioControl && in_that);
16790 
16794  PortfolioControl & operator=(PortfolioControl && in_that);
16795 
16797  ~PortfolioControl();
16798 
16799  HPS::Type ObjectType() const { return HPS::Type::PortfolioControl; };
16800 
16804  PortfolioControl & operator=(PortfolioControl const & in_that);
16805 
16807  size_t GetCount() const;
16808 
16809 
16814  PortfolioControl & Push(PortfolioKey const & in_portfolio);
16815 
16818  bool Pop();
16819 
16823  bool Pop(PortfolioKey & out_portfolio);
16824 
16825 
16829  PortfolioControl & Set(PortfolioKey const & in_portfolio);
16830 
16834  PortfolioControl & Set(PortfolioKeyArray const & in_portfolios);
16835 
16840  PortfolioControl & Set(size_t in_count, PortfolioKey const in_portfolios[]);
16841 
16842 
16845  PortfolioControl & UnsetTop();
16846 
16849  PortfolioControl & UnsetEverything();
16850 
16851 
16855  bool ShowTop(PortfolioKey & out_portfolio) const;
16856 
16860  bool Show(PortfolioKeyArray & out_portfolios) const;
16861 
16862 private:
16863  PortfolioControl();
16864 };
16865 
16866 
16867 
16870 class HPS_API StyleControl : public Control
16871 {
16872 public:
16874  explicit StyleControl(SegmentKey & in_seg);
16875 
16877  StyleControl(StyleControl const & in_that);
16878 
16882  StyleControl(StyleControl && in_that);
16883 
16887  StyleControl & operator=(StyleControl && in_that);
16888 
16890  ~StyleControl();
16891 
16892  HPS::Type ObjectType() const { return HPS::Type::StyleControl; };
16893 
16897  StyleControl & operator=(StyleControl const & in_that);
16898 
16900  size_t GetCount() const;
16901 
16903  StyleKey PushNamed(char const * in_style_name);
16904 
16906  StyleKey PushNamed(char const * in_style_name, Condition const & in_condition);
16907 
16909  StyleKey AppendNamed(char const * in_style_name, Condition const & in_condition, Style::AppendMode mode = Style::AppendMode::Or);
16910 
16914  StyleKey PushSegment(SegmentKey const & in_style_source);
16915 
16919  StyleKey PushSegment(SegmentKey const & in_style_source, Condition const & in_condition);
16920 
16923  StyleKey AppendSegment(SegmentKey const & in_style_source, Condition const & in_condition, Style::AppendMode mode = Style::AppendMode::Or);
16924 
16925 
16926 
16929  bool Pop();
16930 
16937  bool Pop(Style::Type & out_type, SegmentKey & out_segment_source, UTF8 & out_style_name, Condition & out_condition);
16938 
16942  void Flush(SegmentKey const & in_style_source);
16943 
16950  void Flush(SegmentKey const & in_style_source, Condition const & in_condition);
16951 
16955  void Flush(char const * in_style_name);
16956 
16963  void Flush(char const * in_style_name, Condition const & in_condition);
16964 
16965 
16968  StyleKey SetNamed(char const * in_style_name);
16969 
16973  StyleKey SetNamed(char const * in_style_name, Condition const & in_condition);
16974 
16975 
16978  StyleKey SetSegment(SegmentKey const & in_style_source);
16979 
16983  StyleKey SetSegment(SegmentKey const & in_style_source, Condition const & in_condition);
16984 
16985 
16991  void Set(StyleTypeArray const & in_types, SegmentKeyArray const & in_segment_sources, UTF8Array const & in_style_names, ConditionArray const & in_conditions);
16992 
16997  void Set(StyleTypeArray const & in_types, SegmentKeyArray const & in_segment_sources, UTF8Array const & in_style_names);
16998 
17005  void Set(size_t in_count, Style::Type const in_types[], SegmentKey const in_segment_sources[], UTF8 const in_style_names[], Condition const in_conditions[]);
17006 
17007 
17008 
17010  void UnsetTop();
17011 
17013  void UnsetAllSegment();
17014 
17016  void UnsetAllNamed();
17017 
17019  void UnsetEverything();
17020 
17021 
17028  bool ShowTop(Style::Type & out_type, SegmentKey & out_segment_source, UTF8 & out_style_name, Condition & out_condition) const;
17029 
17033  bool ShowTop(StyleKey & out_style) const;
17034 
17041  bool Show(StyleTypeArray & out_types, SegmentKeyArray & out_segment_sources, UTF8Array & out_style_names, ConditionArray & out_conditions) const;
17042 
17046  bool Show(StyleKeyArray & out_styles) const;
17047 
17052  bool ShowAllSegment(SegmentKeyArray & out_segments, HPS::ConditionArray & out_conditions) const;
17053 
17057  bool ShowAllSegment(StyleKeyArray & out_styles) const;
17058 
17063  bool ShowAllNamed(UTF8Array & out_names, HPS::ConditionArray & out_conditions) const;
17064 
17068  bool ShowAllNamed(StyleKeyArray & out_styles) const;
17069 
17070 private:
17071  StyleControl();
17072 };
17073 
17074 
17077 class HPS_API ConditionControl : public Control
17078 {
17079 public:
17081  explicit ConditionControl(SegmentKey & in_seg);
17082 
17084  ConditionControl(ConditionControl const & in_that);
17085 
17089  ConditionControl(ConditionControl && in_that);
17090 
17094  ConditionControl & operator=(ConditionControl && in_that);
17095 
17097  ~ConditionControl();
17098 
17099 
17100  HPS::Type ObjectType() const { return HPS::Type::ConditionControl; };
17101 
17105  ConditionControl & operator=(ConditionControl const & in_that);
17106 
17109  size_t GetCount() const;
17110 
17114  ConditionControl & AddCondition(char const * in_condition);
17115 
17116 
17120  ConditionControl & SetCondition(char const * in_condition);
17121 
17125  ConditionControl & SetConditions(UTF8Array const & in_conditions);
17126 
17131  ConditionControl & SetConditions(size_t in_count, UTF8 const in_conditions []);
17132 
17133 
17137  ConditionControl & UnsetCondition(char const * in_condition);
17138 
17141  ConditionControl & UnsetEverything();
17142 
17143 
17147  bool ShowCondition(char const * in_condition) const;
17148 
17152  bool ShowConditions(UTF8Array & out_conditions) const;
17153 
17154 private:
17156  ConditionControl();
17157 };
17158 
17159 
17162 class HPS_API MaterialKit : public Object
17163 {
17164 public:
17165 
17167  MaterialKit();
17168 
17171  MaterialKit(MaterialKit const & in_kit);
17172 
17176  MaterialKit(MaterialKit && in_that);
17177 
17181  MaterialKit & operator=(MaterialKit && in_that);
17182 
17184  ~MaterialKit();
17185 
17186  HPS::Type ObjectType() const {return HPS::Type::MaterialKit;};
17187 
17190  void Set(MaterialKit const & in_kit);
17191 
17194  void Show(MaterialKit & out_kit) const;
17195 
17199  MaterialKit & operator=(MaterialKit const & in_kit);
17200 
17203  bool Empty() const;
17204 
17208  bool Equals(MaterialKit const & in_kit) const;
17209 
17213  bool operator==(MaterialKit const & in_kit) const;
17214 
17218  bool operator!=(MaterialKit const & in_kit) const;
17219 
17220 
17221  //Set
17222 
17226  MaterialKit & SetDiffuse(RGBColor const & in_color);
17227 
17231  MaterialKit & SetDiffuse(RGBAColor const & in_color);
17232 
17236  MaterialKit & SetDiffuseColor(RGBColor const & in_color);
17237 
17241  MaterialKit & SetDiffuseColor(RGBAColor const & in_color);
17242 
17247  MaterialKit & SetDiffuseAlpha(float in_alpha);
17248 
17255  MaterialKit & SetDiffuseTexture(char const * in_texture_name, size_t in_layer=0);
17256 
17264  MaterialKit & SetDiffuseTexture(char const * in_texture_name, RGBAColor const & in_modulating_color, size_t in_layer=0);
17265 
17270  MaterialKit & SetDiffuseTexture(UTF8Array const & in_texture_names);
17271 
17277  MaterialKit & SetDiffuseTexture(size_t in_count, UTF8 const in_texture_names []);
17278 
17285  MaterialKit & SetDiffuseTexture(UTF8Array const & in_texture_names, RGBAColorArray const & in_modulating_colors);
17286 
17294  MaterialKit & SetDiffuseTexture(size_t in_count, UTF8 const in_texture_names [], RGBAColor const in_modulating_colors []);
17295 
17296 
17300  MaterialKit & SetShader(char const * in_shader_name);
17301 
17302 
17303 
17307  MaterialKit & SetSpecular(RGBAColor const & in_rgba_color);
17308 
17312  MaterialKit & SetSpecular(char const * in_texture_name);
17313 
17318  MaterialKit & SetSpecular(char const * in_texture_name, RGBAColor const & in_modulating_color);
17319 
17320 
17321 
17325  MaterialKit & SetMirror(RGBAColor const & in_rgba_color);
17326 
17330  MaterialKit & SetMirror(char const * in_texture_name);
17331 
17336  MaterialKit & SetMirror(char const * in_texture_name, RGBAColor const & in_modulating_color);
17337 
17338 
17339 
17343  MaterialKit & SetTransmission(char const * in_texture_name);
17344 
17349  MaterialKit & SetTransmission(char const * in_texture_name, RGBAColor const & in_modulating_color);
17350 
17351 
17352 
17356  MaterialKit & SetEmission(RGBAColor const & in_rgba_color);
17357 
17361  MaterialKit & SetEmission(char const * in_texture_name);
17362 
17367  MaterialKit & SetEmission(char const * in_texture_name, RGBAColor const & in_modulating_color);
17368 
17369 
17370 
17374  MaterialKit & SetEnvironmentTexture(char const * in_texture_name);
17375 
17380  MaterialKit & SetEnvironmentTexture(char const * in_texture_name, RGBAColor const & in_modulating_color);
17381 
17385  MaterialKit & SetEnvironmentCubeMap(char const * in_cubemap_name);
17386 
17391  MaterialKit & SetEnvironmentCubeMap(char const * in_cubemap_name, RGBAColor const & in_modulating_color);
17392 
17395  MaterialKit & SetEnvironmentTexture();
17396 
17397 
17401  MaterialKit & SetBump(char const * in_texture_name);
17402 
17403 
17404 
17411  MaterialKit & SetGloss(float in_gloss);
17412 
17415  MaterialKit & UnsetDiffuseColorRGB();
17416 
17419  MaterialKit & UnsetDiffuseColor();
17420 
17423  MaterialKit & UnsetDiffuseAlpha();
17424 
17427  MaterialKit & UnsetDiffuseTexture();
17428 
17432  MaterialKit & UnsetDiffuseTexture(size_t in_layer);
17433 
17436  MaterialKit & UnsetShader();
17437 
17440  MaterialKit & UnsetSpecular();
17441 
17444  MaterialKit & UnsetMirror();
17445 
17448  MaterialKit & UnsetTransmission();
17449 
17452  MaterialKit & UnsetEmission();
17453 
17456  MaterialKit & UnsetEnvironment();
17457 
17460  MaterialKit & UnsetBump();
17461 
17464  MaterialKit & UnsetGloss();
17465 
17468  MaterialKit & UnsetEverything();
17469 
17470 
17473  bool ShowDiffuse() const;
17474 
17478  bool ShowDiffuseColor(RGBColor & out_rgb_color) const;
17479 
17483  bool ShowDiffuseColor(RGBAColor & out_rgba_color) const;
17484 
17488  bool ShowDiffuseAlpha(float & out_alpha) const;
17489 
17496  bool ShowDiffuseTexture(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
17497 
17505  bool ShowDiffuseTexture(size_t in_layer, Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
17506 
17513  bool ShowDiffuseTexture(MaterialTypeArray & out_types, RGBAColorArray & out_colors, UTF8Array & out_texture_names) const;
17514 
17518  bool ShowShader(UTF8 & out_shader_name) const;
17519 
17528  bool ShowSpecular(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
17529 
17538  bool ShowMirror(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
17539 
17540 
17541 
17550  bool ShowTransmission(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
17551 
17552 
17561  bool ShowEmission(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
17562 
17563 
17572  bool ShowEnvironment(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
17573 
17574 
17578  bool ShowBump(UTF8 & out_texture_name) const;
17579 
17584  bool ShowGloss(float & out_gloss) const;
17585 };
17586 
17587 
17589 class HPS_API NURBSSurfaceAttributeKit : public Object
17590 {
17591 public:
17592 
17595 
17599 
17604 
17608  NURBSSurfaceAttributeKit & operator=(NURBSSurfaceAttributeKit && in_that);
17609 
17611  virtual ~NURBSSurfaceAttributeKit();
17612 
17613  HPS::Type ObjectType() const {return HPS::Type::NURBSSurfaceAttributeKit;};
17614 
17618  static NURBSSurfaceAttributeKit GetDefault();
17619 
17622  void Set(NURBSSurfaceAttributeKit const & in_kit);
17623 
17626  void Show(NURBSSurfaceAttributeKit & out_kit) const;
17627 
17631  NURBSSurfaceAttributeKit & operator=(NURBSSurfaceAttributeKit const & in_kit);
17632 
17635  bool Empty() const;
17636 
17640  bool Equals(NURBSSurfaceAttributeKit const & in_kit) const;
17641 
17645  bool operator==(NURBSSurfaceAttributeKit const & in_kit) const;
17646 
17650  bool operator!=(NURBSSurfaceAttributeKit const & in_kit) const;
17651 
17652 
17656  NURBSSurfaceAttributeKit & SetBudget(size_t in_budget);
17657 
17662  NURBSSurfaceAttributeKit & SetMaximumDeviation(float in_deviation);
17663 
17667  NURBSSurfaceAttributeKit & SetMaximumAngle(float in_degrees);
17668 
17672  NURBSSurfaceAttributeKit & SetMaximumWidth(float in_width);
17673 
17677  NURBSSurfaceAttributeKit & SetTrimBudget(size_t in_budget);
17678 
17683  NURBSSurfaceAttributeKit & SetMaximumTrimDeviation(float in_deviation);
17684 
17685 
17688  NURBSSurfaceAttributeKit & UnsetBudget();
17689 
17692  NURBSSurfaceAttributeKit & UnsetMaximumDeviation();
17693 
17696  NURBSSurfaceAttributeKit & UnsetMaximumAngle();
17697 
17700  NURBSSurfaceAttributeKit & UnsetMaximumWidth();
17701 
17704  NURBSSurfaceAttributeKit & UnsetTrimBudget();
17705 
17708  NURBSSurfaceAttributeKit & UnsetMaximumTrimDeviation();
17709 
17712  NURBSSurfaceAttributeKit & UnsetEverything();
17713 
17717  bool ShowBudget(size_t & out_budget) const;
17718 
17722  bool ShowMaximumDeviation(float & out_deviation) const;
17723 
17727  bool ShowMaximumAngle(float & out_degrees) const;
17728 
17732  bool ShowMaximumWidth(float & out_width) const;
17733 
17737  bool ShowTrimBudget(size_t & out_budget) const;
17738 
17742  bool ShowMaximumTrimDeviation(float & out_deviation) const;
17743 };
17744 
17751 {
17752 public:
17753 
17755  explicit NURBSSurfaceAttributeControl(SegmentKey & in_seg);
17756 
17759 
17764 
17769 
17772 
17773  HPS::Type ObjectType() const {return HPS::Type::NURBSSurfaceAttributeControl;};
17774 
17778  NURBSSurfaceAttributeControl & operator=(NURBSSurfaceAttributeControl const & in_that);
17779 
17783  NURBSSurfaceAttributeControl & SetBudget(size_t in_budget);
17784 
17789  NURBSSurfaceAttributeControl & SetMaximumDeviation(float in_deviation);
17790 
17794  NURBSSurfaceAttributeControl & SetMaximumAngle(float in_degrees);
17795 
17799  NURBSSurfaceAttributeControl & SetMaximumWidth(float in_width);
17800 
17804  NURBSSurfaceAttributeControl & SetTrimBudget(size_t in_budget);
17805 
17810  NURBSSurfaceAttributeControl & SetMaximumTrimDeviation(float in_deviation);
17811 
17812 
17815  NURBSSurfaceAttributeControl & UnsetBudget();
17816 
17819  NURBSSurfaceAttributeControl & UnsetMaximumDeviation();
17820 
17823  NURBSSurfaceAttributeControl & UnsetMaximumAngle();
17824 
17827  NURBSSurfaceAttributeControl & UnsetMaximumWidth();
17828 
17831  NURBSSurfaceAttributeControl & UnsetTrimBudget();
17832 
17835  NURBSSurfaceAttributeControl & UnsetMaximumTrimDeviation();
17836 
17839  NURBSSurfaceAttributeControl & UnsetEverything();
17840 
17841 
17845  bool ShowBudget(size_t & out_budget) const;
17846 
17850  bool ShowMaximumDeviation(float & out_deviation) const;
17851 
17855  bool ShowMaximumAngle(float & out_degrees) const;
17856 
17860  bool ShowMaximumWidth(float & out_width) const;
17861 
17865  bool ShowTrimBudget(size_t & out_budget) const;
17866 
17870  bool ShowMaximumTrimDeviation(float & out_deviation) const;
17871 
17872 private:
17875 };
17876 
17877 
17878 
17880 class HPS_API PerformanceKit : public Object
17881 {
17882 public:
17883 
17885  PerformanceKit();
17886 
17889  PerformanceKit(PerformanceKit const & in_kit);
17890 
17894  PerformanceKit(PerformanceKit && in_that);
17895 
17899  PerformanceKit & operator=(PerformanceKit && in_that);
17900 
17902  virtual ~PerformanceKit();
17903 
17904  HPS::Type ObjectType() const {return HPS::Type::PerformanceKit;};
17905 
17909  static PerformanceKit GetDefault();
17910 
17913  void Set(PerformanceKit const & in_kit);
17914 
17917  void Show(PerformanceKit & out_kit) const;
17918 
17922  PerformanceKit & operator=(PerformanceKit const & in_kit);
17923 
17926  bool Empty() const;
17927 
17931  bool Equals(PerformanceKit const & in_kit) const;
17932 
17936  bool operator==(PerformanceKit const & in_kit) const;
17937 
17941  bool operator!=(PerformanceKit const & in_kit) const;
17942 
17943 
17948 
17953  PerformanceKit & SetStaticModel(Performance::StaticModel in_model_type);
17954 
17955 
17958  PerformanceKit & UnsetDisplayLists();
17959 
17962  PerformanceKit & UnsetStaticModel();
17963 
17966  PerformanceKit & UnsetEverything();
17967 
17971  bool ShowDisplayLists(Performance::DisplayLists & out_display_list) const;
17972 
17976  bool ShowStaticModel(Performance::StaticModel & out_model_type) const;
17977 };
17978 
17979 
17985 class HPS_API PerformanceControl : public Control
17986 {
17987 public:
17988 
17990  explicit PerformanceControl(SegmentKey & in_seg);
17991 
17993  PerformanceControl(PerformanceControl const & in_that);
17994 
17999 
18003  PerformanceControl & operator=(PerformanceControl && in_that);
18004 
18006  ~PerformanceControl();
18007 
18008  HPS::Type ObjectType() const {return HPS::Type::PerformanceControl;};
18009 
18013  PerformanceControl & operator=(PerformanceControl const & in_that);
18014 
18019 
18024  PerformanceControl & SetStaticModel(Performance::StaticModel in_model_type);
18025 
18026 
18029  PerformanceControl & UnsetDisplayLists();
18030 
18033  PerformanceControl & UnsetStaticModel();
18034 
18037  PerformanceControl & UnsetEverything();
18038 
18039 
18043  bool ShowDisplayLists(Performance::DisplayLists & out_display_list) const;
18044 
18048  bool ShowStaticModel(Performance::StaticModel & out_model_type) const;
18049 
18050 private:
18053 };
18054 
18055 
18056 
18058 class HPS_API HiddenLineAttributeKit : public Object
18059 {
18060 public:
18061 
18064 
18068 
18073 
18077  HiddenLineAttributeKit & operator=(HiddenLineAttributeKit && in_that);
18078 
18080  virtual ~HiddenLineAttributeKit();
18081 
18082  HPS::Type ObjectType() const {return HPS::Type::HiddenLineAttributeKit;};
18083 
18087  static HiddenLineAttributeKit GetDefault();
18088 
18091  void Set(HiddenLineAttributeKit const & in_kit);
18092 
18095  void Show(HiddenLineAttributeKit & out_kit) const;
18096 
18100  HiddenLineAttributeKit & operator=(HiddenLineAttributeKit const & in_kit);
18101 
18104  bool Empty() const;
18105 
18109  bool Equals(HiddenLineAttributeKit const & in_kit) const;
18110 
18114  bool operator==(HiddenLineAttributeKit const & in_kit) const;
18115 
18119  bool operator!=(HiddenLineAttributeKit const & in_kit) const;
18120 
18121 
18125  HiddenLineAttributeKit & SetColor(RGBAColor const & in_color);
18126 
18132  HiddenLineAttributeKit & SetDimFactor(float in_zero_to_one);
18133 
18143  HiddenLineAttributeKit & SetFaceDisplacement(float in_buckets);
18144 
18148  HiddenLineAttributeKit & SetLinePattern(char const * in_pattern);
18149 
18153  HiddenLineAttributeKit & SetRenderFaces(bool in_state);
18154 
18158  HiddenLineAttributeKit & SetRenderText(bool in_state);
18159 
18164  HiddenLineAttributeKit & SetAlgorithm(HiddenLine::Algorithm in_algorithm);
18165 
18171  HiddenLineAttributeKit & SetSilhouetteCleanup(bool in_state);
18172 
18176  HiddenLineAttributeKit & SetVisibility(bool in_state);
18177 
18182  HiddenLineAttributeKit & SetWeight(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
18183 
18189  HiddenLineAttributeKit & SetTransparencyCutoff(float in_zero_to_one);
18190 
18191 
18194  HiddenLineAttributeKit & UnsetColor();
18195 
18198  HiddenLineAttributeKit & UnsetDimFactor();
18199 
18202  HiddenLineAttributeKit & UnsetFaceDisplacement();
18203 
18206  HiddenLineAttributeKit & UnsetLinePattern();
18207 
18210  HiddenLineAttributeKit & UnsetRenderFaces();
18211 
18214  HiddenLineAttributeKit & UnsetRenderText();
18215 
18218  HiddenLineAttributeKit & UnsetAlgorithm();
18219 
18222  HiddenLineAttributeKit & UnsetSilhouetteCleanup();
18223 
18226  HiddenLineAttributeKit & UnsetVisibility();
18227 
18230  HiddenLineAttributeKit & UnsetWeight();
18231 
18234  HiddenLineAttributeKit & UnsetTransparencyCutoff();
18235 
18238  HiddenLineAttributeKit & UnsetEverything();
18239 
18240 
18244  bool ShowColor(RGBAColor & out_color) const;
18245 
18249  bool ShowDimFactor(float & out_zero_to_one) const;
18250 
18254  bool ShowFaceDisplacement(float & out_buckets) const;
18255 
18259  bool ShowLinePattern(UTF8 & out_pattern) const;
18260 
18264  bool ShowRenderFaces(bool & out_state) const;
18265 
18269  bool ShowRenderText(bool & out_state) const;
18270 
18274  bool ShowAlgorithm(HiddenLine::Algorithm & out_algorithm) const;
18275 
18279  bool ShowSilhouetteCleanup(bool & out_state) const;
18280 
18284  bool ShowVisibility(bool & out_state) const;
18285 
18290  bool ShowWeight(float & out_weight, Line::SizeUnits & out_units) const;
18291 
18295  bool ShowTransparencyCutoff(float & out_zero_to_one) const;
18296 };
18297 
18298 
18304 class HPS_API HiddenLineAttributeControl : public Control
18305 {
18306 public:
18307 
18309  explicit HiddenLineAttributeControl(SegmentKey & in_seg);
18310 
18313 
18318 
18323 
18326 
18327  HPS::Type ObjectType() const {return HPS::Type::HiddenLineAttributeControl;};
18328 
18332  HiddenLineAttributeControl & operator=(HiddenLineAttributeControl const & in_that);
18333 
18337  HiddenLineAttributeControl & SetColor(RGBAColor const & in_color);
18338 
18344  HiddenLineAttributeControl & SetDimFactor(float in_zero_to_one);
18345 
18355  HiddenLineAttributeControl & SetFaceDisplacement(float in_buckets);
18356 
18360  HiddenLineAttributeControl & SetLinePattern(char const * in_pattern);
18361 
18365  HiddenLineAttributeControl & SetRenderFaces(bool in_state);
18366 
18370  HiddenLineAttributeControl & SetRenderText(bool in_state);
18371 
18376  HiddenLineAttributeControl & SetAlgorithm(HiddenLine::Algorithm in_algorithm);
18377 
18383  HiddenLineAttributeControl & SetSilhouetteCleanup(bool in_state);
18384 
18388  HiddenLineAttributeControl & SetVisibility(bool in_state);
18389 
18394  HiddenLineAttributeControl & SetWeight(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
18395 
18401  HiddenLineAttributeControl & SetTransparencyCutoff(float in_zero_to_one);
18402 
18403 
18406  HiddenLineAttributeControl & UnsetColor();
18407 
18410  HiddenLineAttributeControl & UnsetDimFactor();
18411 
18414  HiddenLineAttributeControl & UnsetFaceDisplacement();
18415 
18418  HiddenLineAttributeControl & UnsetLinePattern();
18419 
18422  HiddenLineAttributeControl & UnsetRenderFaces();
18423 
18426  HiddenLineAttributeControl & UnsetRenderText();
18427 
18430  HiddenLineAttributeControl & UnsetAlgorithm();
18431 
18434  HiddenLineAttributeControl & UnsetSilhouetteCleanup();
18435 
18438  HiddenLineAttributeControl & UnsetVisibility();
18439 
18442  HiddenLineAttributeControl & UnsetWeight();
18443 
18446  HiddenLineAttributeControl & UnsetTransparencyCutoff();
18447 
18450  HiddenLineAttributeControl & UnsetEverything();
18451 
18452 
18456  bool ShowColor(RGBAColor & out_color) const;
18457 
18461  bool ShowDimFactor(float & out_zero_to_one) const;
18462 
18466  bool ShowFaceDisplacement(float & out_buckets) const;
18467 
18471  bool ShowLinePattern(UTF8 & out_pattern) const;
18472 
18476  bool ShowRenderFaces(bool & out_state) const;
18477 
18481  bool ShowRenderText(bool & out_state) const;
18482 
18486  bool ShowAlgorithm(HiddenLine::Algorithm & out_algorithm) const;
18487 
18491  bool ShowSilhouetteCleanup(bool & out_state) const;
18492 
18496  bool ShowVisibility(bool & out_state) const;
18497 
18502  bool ShowWeight(float & out_weight, Line::SizeUnits & out_units) const;
18503 
18507  bool ShowTransparencyCutoff(float & out_zero_to_one) const;
18508 
18509 private:
18512 };
18513 
18514 
18515 
18517 class HPS_API DrawingAttributeKit : public Object
18518 {
18519 public:
18520 
18523 
18526  DrawingAttributeKit(DrawingAttributeKit const & in_kit);
18527 
18532 
18536  DrawingAttributeKit & operator=(DrawingAttributeKit && in_that);
18537 
18539  virtual ~DrawingAttributeKit();
18540 
18541  HPS::Type ObjectType() const {return HPS::Type::DrawingAttributeKit;};
18542 
18546  static DrawingAttributeKit GetDefault();
18547 
18550  void Set(DrawingAttributeKit const & in_kit);
18551 
18554  void Show(DrawingAttributeKit & out_kit) const;
18555 
18559  DrawingAttributeKit & operator=(DrawingAttributeKit const & in_kit);
18560 
18563  bool Empty() const;
18564 
18568  bool Equals(DrawingAttributeKit const & in_kit) const;
18569 
18573  bool operator==(DrawingAttributeKit const & in_kit) const;
18574 
18578  bool operator!=(DrawingAttributeKit const & in_kit) const;
18579 
18595  DrawingAttributeKit & SetPolygonHandedness(Drawing::Handedness in_handedness);
18596 
18602  DrawingAttributeKit & SetWorldHandedness(Drawing::Handedness in_handedness);
18603 
18616  DrawingAttributeKit & SetDepthRange(float in_near, float in_far);
18617 
18624  DrawingAttributeKit & SetFaceDisplacement(bool in_state, int in_buckets=0);
18625 
18630  DrawingAttributeKit & SetFaceDisplacement(int in_buckets);
18631 
18638  DrawingAttributeKit & SetGeneralDisplacement(bool in_state, int in_buckets=0);
18639 
18644  DrawingAttributeKit & SetGeneralDisplacement(int in_buckets);
18645 
18652  DrawingAttributeKit & SetVertexDisplacement(bool in_state, int in_buckets=0);
18653 
18658  DrawingAttributeKit & SetVertexDisplacement(int in_buckets);
18659 
18663  DrawingAttributeKit & SetOverlay(Drawing::Overlay in_overlay);
18664 
18669  DrawingAttributeKit & SetDeferral(int in_defer_batch);
18670 
18676  DrawingAttributeKit & SetClipRegion(PointArray const & in_points, Drawing::ClipSpace in_space = Drawing::ClipSpace::World, Drawing::ClipOperation in_operation = Drawing::ClipOperation::Keep);
18677 
18684  DrawingAttributeKit & SetClipRegion(size_t in_point_count, Point const in_points [], Drawing::ClipSpace in_space = Drawing::ClipSpace::World, Drawing::ClipOperation in_operation = Drawing::ClipOperation::Keep);
18685 
18691  DrawingAttributeKit & SetClipRegion(PointArrayArray const & in_loops, Drawing::ClipSpace in_space = Drawing::ClipSpace::World, Drawing::ClipOperation in_operation = Drawing::ClipOperation::Keep);
18692 
18695  DrawingAttributeKit & UnsetPolygonHandedness();
18696 
18699  DrawingAttributeKit & UnsetWorldHandedness();
18700 
18703  DrawingAttributeKit & UnsetDepthRange();
18704 
18707  DrawingAttributeKit & UnsetFaceDisplacement();
18708 
18711  DrawingAttributeKit & UnsetGeneralDisplacement();
18712 
18715  DrawingAttributeKit & UnsetVertexDisplacement();
18716 
18719  DrawingAttributeKit & UnsetOverlay();
18720 
18723  DrawingAttributeKit & UnsetDeferral();
18724 
18727  DrawingAttributeKit & UnsetClipRegion();
18728 
18731  DrawingAttributeKit & UnsetEverything();
18732 
18736  bool ShowPolygonHandedness(Drawing::Handedness & out_handedness) const;
18737 
18741  bool ShowWorldHandedness(Drawing::Handedness & out_handedness) const;
18742 
18747  bool ShowDepthRange(float & out_near, float & out_far) const;
18748 
18753  bool ShowFaceDisplacement(bool & out_state, int & out_buckets) const;
18754 
18759  bool ShowGeneralDisplacement(bool & out_state, int & out_buckets) const;
18760 
18765  bool ShowVertexDisplacement(bool & out_state, int & out_buckets) const;
18766 
18770  bool ShowOverlay(Drawing::Overlay & out_overlay) const;
18771 
18775  bool ShowDeferral(int & out_defer_batch) const;
18776 
18782  bool ShowClipRegion(PointArrayArray & out_loops, Drawing::ClipSpace & out_space, Drawing::ClipOperation & out_operation) const;
18783 
18784 };
18785 
18786 
18798 class HPS_API DrawingAttributeControl : public Control
18799 {
18800 public:
18801 
18803  explicit DrawingAttributeControl(SegmentKey & in_seg);
18804 
18807 
18812 
18816  DrawingAttributeControl & operator=(DrawingAttributeControl && in_that);
18817 
18820 
18821  HPS::Type ObjectType() const {return HPS::Type::DrawingAttributeControl;};
18822 
18826  DrawingAttributeControl & operator=(DrawingAttributeControl const & in_that);
18827 
18837  DrawingAttributeControl & SetPolygonHandedness(Drawing::Handedness in_handedness);
18838 
18844  DrawingAttributeControl & SetWorldHandedness(Drawing::Handedness in_handedness);
18845 
18858  DrawingAttributeControl & SetDepthRange(float in_near, float in_far);
18859 
18866  DrawingAttributeControl & SetFaceDisplacement(bool in_state, int in_buckets=0);
18867 
18872  DrawingAttributeControl & SetFaceDisplacement(int in_buckets);
18873 
18880  DrawingAttributeControl & SetGeneralDisplacement(bool in_state, int in_buckets=0);
18881 
18886  DrawingAttributeControl & SetGeneralDisplacement(int in_buckets);
18887 
18894  DrawingAttributeControl & SetVertexDisplacement(bool in_state, int in_buckets=0);
18895 
18900  DrawingAttributeControl & SetVertexDisplacement(int in_buckets);
18901 
18905  DrawingAttributeControl & SetOverlay(Drawing::Overlay in_overlay);
18906 
18912  DrawingAttributeControl & SetClipRegion(PointArray const & in_points, Drawing::ClipSpace in_space = Drawing::ClipSpace::World, Drawing::ClipOperation in_operation = Drawing::ClipOperation::Keep);
18913 
18920  DrawingAttributeControl & SetClipRegion(size_t in_point_count, Point const in_points [], Drawing::ClipSpace in_space = Drawing::ClipSpace::World, Drawing::ClipOperation in_operation = Drawing::ClipOperation::Keep);
18921 
18927  DrawingAttributeControl & SetClipRegion(PointArrayArray const & in_loops, Drawing::ClipSpace in_space = Drawing::ClipSpace::World, Drawing::ClipOperation in_operation = Drawing::ClipOperation::Keep);
18928 
18933  DrawingAttributeControl & SetDeferral(int in_deferral);
18936  DrawingAttributeControl & UnsetPolygonHandedness();
18937 
18940  DrawingAttributeControl & UnsetWorldHandedness();
18941 
18944  DrawingAttributeControl & UnsetDepthRange();
18945 
18948  DrawingAttributeControl & UnsetFaceDisplacement();
18949 
18952  DrawingAttributeControl & UnsetGeneralDisplacement();
18953 
18956  DrawingAttributeControl & UnsetVertexDisplacement();
18957 
18960  DrawingAttributeControl & UnsetOverlay();
18961 
18964  DrawingAttributeControl & UnsetDeferral();
18965 
18968  DrawingAttributeControl & UnsetClipRegion();
18969 
18972  DrawingAttributeControl & UnsetEverything();
18973 
18974 
18978  bool ShowPolygonHandedness(Drawing::Handedness & out_handedness) const;
18979 
18983  bool ShowWorldHandedness(Drawing::Handedness & out_handedness) const;
18984 
18989  bool ShowDepthRange(float & out_x, float & out_y) const;
18990 
18995  bool ShowFaceDisplacement(bool & out_state, int & out_buckets) const;
18996 
19001  bool ShowGeneralDisplacement(bool & out_state, int & out_buckets) const;
19002 
19007  bool ShowVertexDisplacement(bool & out_state, int & out_buckets) const;
19008 
19012  bool ShowOverlay(Drawing::Overlay & out_overlay) const;
19013 
19017  bool ShowDeferral(int & out_defer_batch) const;
19018 
19024  bool ShowClipRegion(PointArrayArray & out_loops, Drawing::ClipSpace & out_space, Drawing::ClipOperation & out_operation);
19025 
19026 private:
19029 };
19030 
19031 
19033 class HPS_API PostProcessEffectsKit : public Object
19034 {
19035 public:
19036 
19039 
19043 
19048 
19052  PostProcessEffectsKit & operator=(PostProcessEffectsKit && in_that);
19053 
19055  virtual ~PostProcessEffectsKit();
19056 
19057  HPS::Type ObjectType() const {return HPS::Type::PostProcessEffectsKit;};
19058 
19062  static PostProcessEffectsKit GetDefault();
19063 
19066  void Set(PostProcessEffectsKit const & in_kit);
19067 
19070  void Show(PostProcessEffectsKit & out_kit) const;
19071 
19075  PostProcessEffectsKit & operator=(PostProcessEffectsKit const & in_kit);
19076 
19079  bool Empty() const;
19080 
19084  bool Equals(PostProcessEffectsKit const & in_kit) const;
19085 
19089  bool operator==(PostProcessEffectsKit const & in_kit) const;
19090 
19094  bool operator!=(PostProcessEffectsKit const & in_kit) const;
19095 
19096 
19104  PostProcessEffectsKit & SetAmbientOcclusion(bool in_state, float in_strength = 1.0f, PostProcessEffects::AmbientOcclusion::Quality in_quality = PostProcessEffects::AmbientOcclusion::Quality::Fastest);
19105 
19112  PostProcessEffectsKit & SetAmbientOcclusion(float in_strength, PostProcessEffects::AmbientOcclusion::Quality in_quality);
19113 
19120  PostProcessEffectsKit & SetBloom(bool in_state, float in_strength = 1.0f, unsigned int in_blur = 5, PostProcessEffects::Bloom::Shape in_shape = PostProcessEffects::Bloom::Shape::Radial);
19121 
19127  PostProcessEffectsKit & SetBloom(float in_strength, unsigned int in_blur, PostProcessEffects::Bloom::Shape in_shape);
19128 
19135  PostProcessEffectsKit & SetDepthOfField(bool in_state, float in_strength = 1.0f, float in_near_distance = Float::NegativeInfinity, float in_far_distance = Float::Infinity);
19136 
19142  PostProcessEffectsKit & SetDepthOfField(float in_strength, float in_near_distance, float in_far_distance);
19143 
19151  PostProcessEffectsKit & SetSilhouetteEdges(bool in_state, float in_tolerance = 1.0f, bool in_heavy_exterior = false);
19152 
19159  PostProcessEffectsKit & SetSilhouetteEdges(float in_tolerance, bool in_heavy_exterior);
19160 
19168  PostProcessEffectsKit & SetEyeDomeLighting(bool in_state, float in_exponent = 50.0f, float in_tolerance = 1.0f, float in_strength = 1.0f);
19169 
19176  PostProcessEffectsKit & SetEyeDomeLighting(float in_exponent, bool in_tolerance, float in_strength);
19177 
19180  PostProcessEffectsKit & UnsetAmbientOcclusion();
19181 
19184  PostProcessEffectsKit & UnsetBloom();
19185 
19188  PostProcessEffectsKit & UnsetDepthOfField();
19189 
19192  PostProcessEffectsKit & UnsetSilhouetteEdges();
19193 
19196  PostProcessEffectsKit & UnsetEyeDomeLighting();
19197 
19200  PostProcessEffectsKit & UnsetEverything();
19201 
19202 
19209  bool ShowAmbientOcclusion(bool & out_state, float & out_strength, PostProcessEffects::AmbientOcclusion::Quality & out_quality) const;
19210 
19217  bool ShowBloom(bool & out_state, float & out_strength, unsigned int & out_blur, PostProcessEffects::Bloom::Shape & out_shape) const;
19218 
19225  bool ShowDepthOfField(bool & out_state, float & out_strength, float & out_near_distance, float & out_far_distance) const;
19226 
19234  bool ShowSilhouetteEdges(bool & out_state, float & out_tolerance, bool & out_heavy_exterior) const;
19235 
19243  bool ShowEyeDomeLighting(bool & out_state, float & out_exponent, float & out_tolerance, float & out_strength) const;
19244 };
19245 
19246 
19250 class HPS_API PostProcessEffectsControl : public Control
19251 {
19252 public:
19253 
19255  explicit PostProcessEffectsControl(WindowKey & in_seg);
19256 
19259 
19264 
19268  PostProcessEffectsControl & operator=(PostProcessEffectsControl && in_that);
19269 
19272 
19273  HPS::Type ObjectType() const {return HPS::Type::PostProcessEffectsControl;};
19274 
19278  PostProcessEffectsControl & operator=(PostProcessEffectsControl const & in_that);
19279 
19287  PostProcessEffectsControl & SetAmbientOcclusion(bool in_state, float in_strength = 1.0f, PostProcessEffects::AmbientOcclusion::Quality in_quality = PostProcessEffects::AmbientOcclusion::Quality::Fastest);
19288 
19295  PostProcessEffectsControl & SetAmbientOcclusion(float in_strength, PostProcessEffects::AmbientOcclusion::Quality in_quality);
19296 
19303  PostProcessEffectsControl & SetBloom(bool in_state, float in_strength = 1.0f, unsigned int in_blur = 5, PostProcessEffects::Bloom::Shape in_shape = PostProcessEffects::Bloom::Shape::Radial);
19304 
19310  PostProcessEffectsControl & SetBloom(float in_strength, unsigned int in_blur, PostProcessEffects::Bloom::Shape in_shape);
19311 
19318  PostProcessEffectsControl & SetDepthOfField(bool in_state, float in_strength = 1.0f, float in_near_distance = Float::NegativeInfinity, float in_far_distance = Float::Infinity);
19319 
19325  PostProcessEffectsControl & SetDepthOfField(float in_strength, float in_near_distance, float in_far_distance);
19326 
19334  PostProcessEffectsControl & SetSilhouetteEdges(bool in_state, float in_tolerance = 1.0f, bool in_heavy_exterior = false);
19335 
19342  PostProcessEffectsControl & SetSilhouetteEdges(float in_tolerance, bool in_heavy_exterior);
19343 
19351  PostProcessEffectsControl & SetEyeDomeLighting(bool in_state, float in_exponent = 50.0f, float in_tolerance = 1.0f, float in_strength = 1.0f);
19352 
19359  PostProcessEffectsControl & SetEyeDomeLighting(float in_exponent, float in_tolerance, float in_strength);
19360 
19361 
19364  PostProcessEffectsControl & UnsetAmbientOcclusion();
19365 
19368  PostProcessEffectsControl & UnsetBloom();
19369 
19372  PostProcessEffectsControl & UnsetDepthOfField();
19373 
19376  PostProcessEffectsControl & UnsetSilhouetteEdges();
19377 
19380  PostProcessEffectsControl & UnsetEyeDomeLighting();
19381 
19384  PostProcessEffectsControl & UnsetEverything();
19385 
19386 
19393  bool ShowAmbientOcclusion(bool & out_state, float & out_strength, PostProcessEffects::AmbientOcclusion::Quality & out_quality) const;
19394 
19401  bool ShowBloom(bool & out_state, float & out_strength, unsigned int & out_blur, PostProcessEffects::Bloom::Shape & out_shape) const;
19402 
19409  bool ShowDepthOfField(bool & out_state, float & out_strength, float & out_near_distance, float & out_far_distance) const;
19410 
19418  bool ShowSilhouetteEdges(bool & out_state, float & out_tolerance, bool & out_heavy_exterior) const;
19419 
19427  bool ShowEyeDomeLighting(bool & out_state, float & out_exponent, float & out_tolerance, float & out_strength) const;
19428 
19429 private:
19432 };
19433 
19435 class HPS_API TransformMaskKit : public Object
19436 {
19437 public:
19438 
19440  TransformMaskKit();
19441 
19443  TransformMaskKit(TransformMaskKit const & in_kit);
19444 
19448  TransformMaskKit(TransformMaskKit && in_that);
19449 
19453  TransformMaskKit & operator=(TransformMaskKit && in_that);
19454 
19456  virtual ~TransformMaskKit();
19457 
19458  HPS::Type ObjectType() const {return HPS::Type::TransformMaskKit;};
19459 
19460  static TransformMaskKit GetDefault();
19461 
19463  void Set(TransformMaskKit const & in_kit);
19464 
19466  void Show(TransformMaskKit & out_kit) const;
19467 
19469  TransformMaskKit & operator=(TransformMaskKit const & in_kit);
19470 
19472  bool Empty() const;
19473 
19475  bool Equals(TransformMaskKit const & in_kit) const;
19476 
19478  bool operator==(TransformMaskKit const & in_kit) const;
19479 
19481  bool operator!=(TransformMaskKit const & in_kit) const;
19482 
19483 
19487  TransformMaskKit & SetCameraRotation(bool in_state);
19488 
19492  TransformMaskKit & SetCameraScale(bool in_state);
19493 
19497  TransformMaskKit & SetCameraTranslation(bool in_state);
19498 
19502  TransformMaskKit & SetCameraPerspectiveScale(bool in_state);
19503 
19507  TransformMaskKit & SetCameraProjection(bool in_state);
19508 
19512  TransformMaskKit & SetCameraOffset(bool in_state);
19513 
19517  TransformMaskKit & SetCameraNearLimit(bool in_state);
19518 
19522  TransformMaskKit & SetModellingMatrixRotation(bool in_state);
19523 
19527  TransformMaskKit & SetModellingMatrixScale(bool in_state);
19528 
19532  TransformMaskKit & SetModellingMatrixTranslation(bool in_state);
19533 
19537  TransformMaskKit & SetModellingMatrixOffset(bool in_state);
19538 
19539 
19543  TransformMaskKit & SetCameraEverything(bool in_state);
19544 
19548  TransformMaskKit & SetModellingMatrixEverything(bool in_state);
19549 
19553  TransformMaskKit & SetEverything(bool in_state);
19554 
19555 
19558  TransformMaskKit & UnsetCameraRotation();
19559 
19562  TransformMaskKit & UnsetCameraScale();
19563 
19566  TransformMaskKit & UnsetCameraTranslation();
19567 
19570  TransformMaskKit & UnsetCameraPerspectiveScale();
19571 
19574  TransformMaskKit & UnsetCameraProjection();
19575 
19578  TransformMaskKit & UnsetCameraOffset();
19579 
19582  TransformMaskKit & UnsetCameraNearLimit();
19583 
19586  TransformMaskKit & UnsetCameraEverything();
19587 
19590  TransformMaskKit & UnsetModellingMatrixRotation();
19591 
19594  TransformMaskKit & UnsetModellingMatrixScale();
19595 
19598  TransformMaskKit & UnsetModellingMatrixTranslation();
19599 
19602  TransformMaskKit & UnsetModellingMatrixOffset();
19603 
19606  TransformMaskKit & UnsetModellingMatrixEverything();
19607 
19610  TransformMaskKit & UnsetEverything();
19611 
19612 
19616  bool ShowCameraRotation(bool & out_state) const;
19617 
19621  bool ShowCameraScale(bool & out_state) const;
19622 
19626  bool ShowCameraTranslation(bool & out_state) const;
19627 
19631  bool ShowCameraPerspectiveScale(bool & out_state) const;
19632 
19636  bool ShowCameraProjection(bool & out_state) const;
19637 
19641  bool ShowCameraOffset(bool & out_state) const;
19642 
19646  bool ShowCameraNearLimit(bool & out_state) const;
19647 
19651  bool ShowModellingMatrixRotation(bool & out_state) const;
19652 
19656  bool ShowModellingMatrixScale(bool & out_state) const;
19657 
19661  bool ShowModellingMatrixTranslation(bool & out_state) const;
19662 
19666  bool ShowModellingMatrixOffset(bool & out_state) const;
19667 };
19668 
19669 
19674 class HPS_API TransformMaskControl : public Control
19675 {
19676 public:
19677 
19679  explicit TransformMaskControl(SegmentKey & in_seg);
19680 
19682  TransformMaskControl(TransformMaskControl const & in_that);
19683 
19688 
19692  TransformMaskControl & operator=(TransformMaskControl && in_that);
19693 
19696 
19697  HPS::Type ObjectType() const {return HPS::Type::TransformMaskControl;};
19698 
19702  TransformMaskControl & operator=(TransformMaskControl const & in_that);
19703 
19707  TransformMaskControl & SetCameraRotation(bool in_state);
19708 
19712  TransformMaskControl & SetCameraScale(bool in_state);
19713 
19717  TransformMaskControl & SetCameraTranslation(bool in_state);
19718 
19722  TransformMaskControl & SetCameraPerspectiveScale(bool in_state);
19723 
19727  TransformMaskControl & SetCameraProjection(bool in_state);
19728 
19732  TransformMaskControl & SetCameraOffset(bool in_state);
19733 
19737  TransformMaskControl & SetCameraNearLimit(bool in_state);
19738 
19742  TransformMaskControl & SetModellingMatrixRotation(bool in_state);
19743 
19747  TransformMaskControl & SetModellingMatrixScale(bool in_state);
19748 
19752  TransformMaskControl & SetModellingMatrixTranslation(bool in_state);
19753 
19757  TransformMaskControl & SetModellingMatrixOffset(bool in_state);
19758 
19759 
19763  TransformMaskControl & SetCameraEverything(bool in_state);
19764 
19768  TransformMaskControl & SetModellingMatrixEverything(bool in_state);
19769 
19773  TransformMaskControl & SetEverything(bool in_state);
19774 
19775 
19778  TransformMaskControl & UnsetCameraRotation();
19779 
19782  TransformMaskControl & UnsetCameraScale();
19783 
19786  TransformMaskControl & UnsetCameraTranslation();
19787 
19790  TransformMaskControl & UnsetCameraPerspectiveScale();
19791 
19794  TransformMaskControl & UnsetCameraProjection();
19795 
19798  TransformMaskControl & UnsetCameraOffset();
19799 
19802  TransformMaskControl & UnsetCameraNearLimit();
19803 
19806  TransformMaskControl & UnsetCameraEverything();
19807 
19810  TransformMaskControl & UnsetModellingMatrixRotation();
19811 
19814  TransformMaskControl & UnsetModellingMatrixScale();
19815 
19818  TransformMaskControl & UnsetModellingMatrixTranslation();
19819 
19822  TransformMaskControl & UnsetModellingMatrixOffset();
19823 
19826  TransformMaskControl & UnsetModellingMatrixEverything();
19827 
19830  TransformMaskControl & UnsetEverything();
19831 
19832 
19836  bool ShowCameraRotation(bool & out_state) const;
19837 
19841  bool ShowCameraScale(bool & out_state) const;
19842 
19846  bool ShowCameraTranslation(bool & out_state) const;
19847 
19851  bool ShowCameraPerspectiveScale(bool & out_state) const;
19852 
19856  bool ShowCameraProjection(bool & out_state) const;
19857 
19861  bool ShowCameraOffset(bool & out_state) const;
19862 
19866  bool ShowCameraNearLimit(bool & out_state) const;
19867 
19871  bool ShowModellingMatrixRotation(bool & out_state) const;
19872 
19876  bool ShowModellingMatrixScale(bool & out_state) const;
19877 
19881  bool ShowModellingMatrixTranslation(bool & out_state) const;
19882 
19886  bool ShowModellingMatrixOffset(bool & out_state) const;
19887 
19888 private:
19891 };
19892 
19893 
19894 
19896 class HPS_API VisualEffectsKit : public Object
19897 {
19898 public:
19899 
19901  VisualEffectsKit();
19902 
19905  VisualEffectsKit(VisualEffectsKit const & in_kit);
19906 
19910  VisualEffectsKit(VisualEffectsKit && in_that);
19911 
19915  VisualEffectsKit & operator=(VisualEffectsKit && in_that);
19916 
19918  virtual ~VisualEffectsKit();
19919 
19920  HPS::Type ObjectType() const {return HPS::Type::VisualEffectsKit;};
19921 
19925  static VisualEffectsKit GetDefault();
19926 
19929  void Set(VisualEffectsKit const & in_kit);
19930 
19933  void Show(VisualEffectsKit & out_kit) const;
19934 
19938  VisualEffectsKit & operator=(VisualEffectsKit const & in_kit);
19939 
19942  bool Empty() const;
19943 
19947  bool Equals(VisualEffectsKit const & in_kit) const;
19948 
19952  bool operator==(VisualEffectsKit const & in_kit) const;
19953 
19957  bool operator!=(VisualEffectsKit const & in_kit) const;
19958 
19962  VisualEffectsKit & SetPostProcessEffectsEnabled(bool in_state);
19963 
19967  VisualEffectsKit & SetAntiAliasing(bool in_state);
19968 
19978  VisualEffectsKit & SetShadowMaps(bool in_state, unsigned int in_samples = 4, unsigned int in_resolution = 1024, bool in_view_dependent = true, bool in_jitter = true);
19979 
19988  VisualEffectsKit & SetShadowMaps(unsigned int in_samples, unsigned int in_resolution, bool in_view_dependent, bool in_jitter);
19989 
19996  VisualEffectsKit & SetSimpleShadow(bool in_state, unsigned int in_resolution = 256, unsigned int in_blurring = 1, bool in_ignore_transparency = false);
19997 
20003  VisualEffectsKit & SetSimpleShadow(unsigned int in_resolution, unsigned int in_blurring, bool in_ignore_transparency);
20004 
20008  VisualEffectsKit & SetSimpleShadowPlane(Plane const & in_projected_onto = Plane(0.0f, 1.0f, 0.0f, 1.0f));
20009 
20013  VisualEffectsKit & SetSimpleShadowLightDirection(Vector const & in_direction = Vector(0.0f, 1.0f, 0.0f));
20014 
20018  VisualEffectsKit & SetSimpleShadowColor(RGBAColor const & in_color = RGBAColor(0.0f, 0.0f, 0.0f, 1.0f));
20019 
20030  VisualEffectsKit & SetSimpleReflection(bool in_state, float in_opacity = 0.5f, unsigned int in_blurring = 1, bool in_fading = false, float in_attenuation_near_distance = 0.0f, float in_attenuation_far_distance = Float::Infinity);
20031 
20041  VisualEffectsKit & SetSimpleReflection(float in_opacity, unsigned int in_blurring, bool in_fading, float in_attenuation_near_distance, float in_attenuation_far_distance);
20042 
20046  VisualEffectsKit & SetSimpleReflectionPlane(Plane const & in_projected_onto = Plane(0.0f, 1.0f, 0.0f, 1.0f));
20047 
20051  VisualEffectsKit & SetSimpleReflectionVisibility(VisibilityKit const & in_reflected_types);
20052 
20053 
20056  VisualEffectsKit & UnsetPostProcessEffectsEnabled();
20057 
20060  VisualEffectsKit & UnsetAntiAliasing();
20061 
20064  VisualEffectsKit & UnsetShadowMaps();
20065 
20068  VisualEffectsKit & UnsetSimpleShadow();
20069 
20072  VisualEffectsKit & UnsetSimpleShadowPlane();
20073 
20076  VisualEffectsKit & UnsetSimpleShadowLightDirection();
20077 
20080  VisualEffectsKit & UnsetSimpleShadowColor();
20081 
20084  VisualEffectsKit & UnsetSimpleReflection();
20085 
20088  VisualEffectsKit & UnsetSimpleReflectionPlane();
20089 
20092  VisualEffectsKit & UnsetSimpleReflectionVisibility();
20093 
20096  VisualEffectsKit & UnsetEverything();
20097 
20101  bool ShowPostProcessEffectsEnabled(bool & out_state) const;
20102 
20106  bool ShowAntiAliasing(bool & out_state) const;
20107 
20115  bool ShowShadowMaps(bool & out_state, unsigned int & out_samples, unsigned int & out_resolution, bool & out_view_dependent, bool & out_jitter) const;
20116 
20123  bool ShowSimpleShadow(bool & out_state, unsigned int & out_resolution, unsigned int & out_blurring, bool & out_ignore_transparency) const;
20124 
20128  bool ShowSimpleShadowPlane(Plane & out_projected_onto) const;
20129 
20133  bool ShowSimpleShadowLightDirection(Vector & out_direction) const;
20134 
20138  bool ShowSimpleShadowColor(RGBAColor & out_color) const;
20139 
20148  bool ShowSimpleReflection(bool & out_state, float & out_opacity, unsigned int & out_blurring, bool & out_fading, float & out_attenuation_near_distance, float & out_attenuation_far_distance) const;
20149 
20150 
20154  bool ShowSimpleReflectionPlane(Plane & out_projected_onto) const;
20155 
20159  bool ShowSimpleReflectionVisibility(VisibilityKit & out_reflected_types) const;
20160 };
20161 
20162 
20168 class HPS_API VisualEffectsControl : public Control
20169 {
20170 public:
20171 
20173  explicit VisualEffectsControl(SegmentKey & in_seg);
20174 
20176  VisualEffectsControl(VisualEffectsControl const & in_that);
20177 
20182 
20186  VisualEffectsControl & operator=(VisualEffectsControl && in_that);
20187 
20190 
20191  HPS::Type ObjectType() const {return HPS::Type::VisualEffectsControl;};
20192 
20196  VisualEffectsControl & operator=(VisualEffectsControl const & in_that);
20197 
20201  VisualEffectsControl & SetPostProcessEffectsEnabled(bool in_state);
20202 
20206  VisualEffectsControl & SetAntiAliasing(bool in_state);
20207 
20217  VisualEffectsControl & SetShadowMaps(bool in_state, unsigned int in_samples = 4, unsigned int in_resolution = 1024, bool in_view_dependent = true, bool in_jitter = true);
20218 
20227  VisualEffectsControl & SetShadowMaps(unsigned int in_samples, unsigned int in_resolution, bool in_view_dependent, bool in_jitter);
20228 
20235  VisualEffectsControl & SetSimpleShadow(bool in_state, unsigned int in_resolution = 256, unsigned int in_blurring = 1, bool in_ignore_transparency = false);
20236 
20242  VisualEffectsControl & SetSimpleShadow(unsigned int in_resolution, unsigned int in_blurring, bool in_ignore_transparency);
20243 
20247  VisualEffectsControl & SetSimpleShadowPlane(Plane const & in_projected_onto = Plane(0.0f, 1.0f, 0.0f, 1.0f));
20248 
20252  VisualEffectsControl & SetSimpleShadowLightDirection(Vector const & in_direction = Vector(0.0f, 1.0f, 0.0f));
20253 
20257  VisualEffectsControl & SetSimpleShadowColor(RGBAColor const & in_color = RGBAColor(0.0f, 0.0f, 0.0f, 1.0f));
20258 
20269  VisualEffectsControl & SetSimpleReflection(bool in_state, float in_opacity = 0.5f, unsigned int in_blurring = 1, bool in_fading = false, float in_attenuation_near_distance = 0.0f, float in_attenuation_far_distance = Float::Infinity);
20270 
20280  VisualEffectsControl & SetSimpleReflection(float in_opacity, unsigned int in_blurring, bool in_fading, float in_attenuation_near_distance, float in_attenuation_far_distance);
20281 
20285  VisualEffectsControl & SetSimpleReflectionPlane(Plane const & in_projected_onto = Plane(0.0f, 1.0f, 0.0f, 1.0f));
20286 
20290  VisualEffectsControl & SetSimpleReflectionVisibility(VisibilityKit const & in_reflected_types);
20291 
20292 
20295  VisualEffectsControl & UnsetPostProcessEffectsEnabled();
20296 
20299  VisualEffectsControl & UnsetAntiAliasing();
20300 
20303  VisualEffectsControl & UnsetShadowMaps();
20304 
20307  VisualEffectsControl & UnsetSimpleShadow();
20308 
20311  VisualEffectsControl & UnsetSimpleShadowPlane();
20312 
20315  VisualEffectsControl & UnsetSimpleShadowLightDirection();
20316 
20319  VisualEffectsControl & UnsetSimpleShadowColor();
20320 
20323  VisualEffectsControl & UnsetSimpleReflection();
20324 
20327  VisualEffectsControl & UnsetSimpleReflectionPlane();
20328 
20331  VisualEffectsControl & UnsetSimpleReflectionVisibility();
20332 
20335  VisualEffectsControl & UnsetEverything();
20336 
20337 
20341  bool ShowPostProcessEffectsEnabled(bool & out_state) const;
20342 
20346  bool ShowAntiAliasing(bool & out_state) const;
20347 
20355  bool ShowShadowMaps(bool & out_state, unsigned int & out_samples, unsigned int & out_resolution, bool & out_view_dependent, bool & out_jitter) const;
20356 
20363  bool ShowSimpleShadow(bool & out_state, unsigned int & out_resolution, unsigned int & out_blurring, bool & out_ignore_transparency) const;
20364 
20368  bool ShowSimpleShadowPlane(Plane & out_projected_onto) const;
20369 
20373  bool ShowSimpleShadowLightDirection(Vector & out_direction) const;
20374 
20378  bool ShowSimpleShadowColor(RGBAColor & out_color) const;
20379 
20388  bool ShowSimpleReflection(bool & out_state, float & out_opacity, unsigned int & out_blurring, bool & out_fading, float & out_attenuation_near_distance, float & out_attenuation_far_distance) const;
20389 
20393  bool ShowSimpleReflectionPlane(Plane & out_projected_onto) const;
20394 
20398  bool ShowSimpleReflectionVisibility(VisibilityKit & out_reflected_types) const;
20399 
20400 private:
20403 };
20404 
20405 
20406 
20408 class HPS_API ContourLineKit : public Object
20409 {
20410 public:
20411 
20413  ContourLineKit();
20414 
20417  ContourLineKit(ContourLineKit const & in_kit);
20418 
20422  ContourLineKit(ContourLineKit && in_that);
20423 
20427  ContourLineKit & operator=(ContourLineKit && in_that);
20428 
20430  virtual ~ContourLineKit();
20431 
20432  HPS::Type ObjectType() const { return HPS::Type::ContourLineKit; };
20433 
20437  static ContourLineKit GetDefault();
20438 
20441  void Set(ContourLineKit const & in_kit);
20442 
20445  void Show(ContourLineKit & out_kit) const;
20446 
20450  ContourLineKit & operator=(ContourLineKit const & in_kit);
20451 
20454  bool Empty() const;
20455 
20459  bool Equals(ContourLineKit const & in_kit) const;
20460 
20464  bool operator==(ContourLineKit const & in_kit) const;
20465 
20469  bool operator!=(ContourLineKit const & in_kit) const;
20470 
20471 
20475  ContourLineKit & SetVisibility(bool in_state);
20476 
20481  ContourLineKit & SetPositions(float in_interval, float in_offset);
20482 
20486  ContourLineKit & SetPositions(FloatArray const & in_positions);
20487 
20492  ContourLineKit & SetPositions(size_t in_count, float const in_positions[]);
20493 
20497  ContourLineKit & SetColors(RGBColorArray const & in_colors);
20498 
20503  ContourLineKit & SetColors(size_t in_count, RGBColor const in_colors[]);
20504 
20508  ContourLineKit & SetColors(RGBColor const & in_color);
20509 
20513  ContourLineKit & SetPatterns(UTF8Array const & in_patterns);
20514 
20519  ContourLineKit & SetPatterns(size_t in_count, UTF8 const in_patterns[]);
20520 
20524  ContourLineKit & SetPatterns(char const * in_pattern);
20525 
20530  ContourLineKit & SetWeights(FloatArray const & in_weights, LineSizeUnitsArray const & in_units);
20531 
20537  ContourLineKit & SetWeights(size_t in_count, float const in_weights[], Line::SizeUnits const in_units[]);
20538 
20543  ContourLineKit & SetWeights(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
20544 
20548  ContourLineKit & SetLighting(bool in_state);
20549 
20550 
20553  ContourLineKit & UnsetVisibility();
20554 
20557  ContourLineKit & UnsetPositions();
20558 
20561  ContourLineKit & UnsetColors();
20562 
20565  ContourLineKit & UnsetPatterns();
20566 
20569  ContourLineKit & UnsetWeights();
20570 
20573  ContourLineKit & UnsetLighting();
20574 
20577  ContourLineKit & UnsetEverything();
20578 
20579 
20583  bool ShowVisibility(bool & out_state) const;
20584 
20590  bool ShowPositions(ContourLine::Mode & out_mode, FloatArray & out_positions) const;
20591 
20595  bool ShowColors(RGBColorArray & out_colors) const;
20596 
20600  bool ShowPatterns(UTF8Array & out_patterns) const;
20601 
20606  bool ShowWeights(FloatArray & out_weights, LineSizeUnitsArray & out_units) const;
20607 
20611  bool ShowLighting(bool & out_state) const;
20612 };
20613 
20617 class HPS_API ContourLineControl : public Control
20618 {
20619 public:
20620 
20622  explicit ContourLineControl(SegmentKey & in_seg);
20623 
20625  ContourLineControl(ContourLineControl const & in_that);
20626 
20631 
20635  ContourLineControl & operator=(ContourLineControl && in_that);
20636 
20638  ~ContourLineControl();
20639 
20640  HPS::Type ObjectType() const { return HPS::Type::ContourLineControl; };
20641 
20645  ContourLineControl & operator=(ContourLineControl const & in_that);
20646 
20650  ContourLineControl & SetVisibility(bool in_state);
20651 
20656  ContourLineControl & SetPositions(float in_interval, float in_offset);
20657 
20661  ContourLineControl & SetPositions(FloatArray const & in_positions);
20662 
20667  ContourLineControl & SetPositions(size_t in_count, float const in_positions[]);
20668 
20672  ContourLineControl & SetColors(RGBColorArray const & in_colors);
20673 
20678  ContourLineControl & SetColors(size_t in_count, RGBColor const in_colors[]);
20679 
20683  ContourLineControl & SetColors(RGBColor const & in_rgb_color);
20684 
20688  ContourLineControl & SetPatterns(UTF8Array const & in_patterns);
20689 
20694  ContourLineControl & SetPatterns(size_t in_count, UTF8 const in_patterns[]);
20695 
20699  ContourLineControl & SetPatterns(char const * in_pattern);
20700 
20705  ContourLineControl & SetWeights(FloatArray const & in_weights, LineSizeUnitsArray const & in_units);
20706 
20712  ContourLineControl & SetWeights(size_t in_count, float const in_weights[], Line::SizeUnits const in_units[]);
20713 
20718  ContourLineControl & SetWeights(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
20719 
20723  ContourLineControl & SetLighting(bool in_state);
20724 
20725 
20728  ContourLineControl & UnsetVisibility();
20729 
20732  ContourLineControl & UnsetPositions();
20733 
20736  ContourLineControl & UnsetColors();
20737 
20740  ContourLineControl & UnsetPatterns();
20741 
20744  ContourLineControl & UnsetWeights();
20745 
20748  ContourLineControl & UnsetLighting();
20749 
20752  ContourLineControl & UnsetEverything();
20753 
20754 
20758  bool ShowVisibility(bool & out_state) const;
20759 
20765  bool ShowPositions(ContourLine::Mode & out_mode, FloatArray & out_positions) const;
20766 
20770  bool ShowColors(RGBColorArray & out_colors) const;
20771 
20775  bool ShowPatterns(UTF8Array & out_patterns) const;
20776 
20781  bool ShowWeights(FloatArray & out_weights, LineSizeUnitsArray & out_units) const;
20782 
20786  bool ShowLighting(bool & out_state) const;
20787 
20788 private:
20791 };
20792 
20793 
20794 
20796 class HPS_API SubwindowKit : public Object
20797 {
20798 public:
20799 
20801  SubwindowKit();
20802 
20804  SubwindowKit(SubwindowKit const & in_kit);
20805 
20809  SubwindowKit(SubwindowKit && in_that);
20810 
20814  SubwindowKit & operator=(SubwindowKit && in_that);
20815 
20817  virtual ~SubwindowKit();
20818 
20819  HPS::Type ObjectType() const {return HPS::Type::SubwindowKit;}
20820 
20824  static SubwindowKit GetDefault();
20825 
20828  void Set(SubwindowKit const & in_kit);
20829 
20832  void Show(SubwindowKit & out_kit) const;
20833 
20837  SubwindowKit & operator=(SubwindowKit const & in_kit);
20838 
20841  bool Empty() const;
20842 
20846  bool Equals(SubwindowKit const & in_kit) const;
20847 
20851  bool operator==(SubwindowKit const & in_kit) const;
20852 
20856  bool operator!=(SubwindowKit const & in_kit) const;
20857 
20858 
20868  SubwindowKit & SetSubwindow(Rectangle const & in_subwindow_position, Subwindow::Type in_subwindow_type = Subwindow::Type::Standard);
20869 
20876  SubwindowKit & SetBackground(Subwindow::Background in_bg_type, char const * in_definition_name = "");
20877 
20882  SubwindowKit & SetBorder(Subwindow::Border in_border_type);
20883 
20888  SubwindowKit & SetRenderingAlgorithm(Subwindow::RenderingAlgorithm in_hsra);
20889 
20895  SubwindowKit & SetModelCompareMode(bool in_state, SegmentKey const & in_source1 = SegmentKey(), SegmentKey const & in_source2 = SegmentKey());
20896 
20901  SubwindowKit & SetModelCompareMode(SegmentKey const & in_source1, SegmentKey const & in_source2);
20902 
20905  SubwindowKit & UnsetSubwindow();
20906 
20909  SubwindowKit & UnsetBackground();
20910 
20913  SubwindowKit & UnsetBorder();
20914 
20917  SubwindowKit & UnsetRenderingAlgorithm();
20918 
20921  SubwindowKit & UnsetModelCompareMode();
20922 
20925  SubwindowKit & UnsetEverything();
20926 
20931  bool ShowSubwindow(Rectangle & out_subwindow_position, Subwindow::Type & out_subwindow_type) const;
20932 
20937  bool ShowBackground(Subwindow::Background & out_bg_type, UTF8 & out_definition_name) const;
20938 
20942  bool ShowBorder(Subwindow::Border & out_border_type) const;
20943 
20947  bool ShowRenderingAlgorithm(Subwindow::RenderingAlgorithm & out_hsra) const;
20948 
20954  bool ShowModelCompareMode(bool & out_state, SegmentKey & out_source1, SegmentKey & out_source2) const;
20955 };
20956 
20957 
20958 
20964 class HPS_API SubwindowControl : public Control
20965 {
20966 public:
20967 
20969  explicit SubwindowControl(SegmentKey & in_seg);
20970 
20972  SubwindowControl(SubwindowControl const & in_that);
20973 
20977  SubwindowControl(SubwindowControl && in_that);
20978 
20982  SubwindowControl & operator=(SubwindowControl && in_that);
20983 
20985  ~SubwindowControl();
20986 
20987  HPS::Type ObjectType() const {return HPS::Type::SubwindowControl;}
20988 
20992  SubwindowControl & operator=(SubwindowControl const & in_that);
20993 
21004  SubwindowControl & SetSubwindow(Rectangle const & in_window_position, Subwindow::Type in_type = Subwindow::Type::Standard);
21005 
21012  SubwindowControl & SetBackground(Subwindow::Background in_bg_type, char const * in_definition_name = "");
21013 
21018  SubwindowControl & SetBorder(Subwindow::Border in_border_type);
21019 
21025  SubwindowControl & SetRenderingAlgorithm(Subwindow::RenderingAlgorithm in_hsra);
21026 
21032  SubwindowControl & SetModelCompareMode(bool in_state, SegmentKey const & in_source1 = SegmentKey(), SegmentKey const & in_source2 = SegmentKey());
21033 
21038  SubwindowControl & SetModelCompareMode(SegmentKey const & in_source1, SegmentKey const & in_source2);
21039 
21042  SubwindowControl & UnsetSubwindow();
21043 
21046  SubwindowControl & UnsetBackground();
21047 
21050  SubwindowControl & UnsetBorder();
21051 
21054  SubwindowControl & UnsetRenderingAlgorithm();
21055 
21058  SubwindowControl & UnsetModelCompareMode();
21059 
21062  SubwindowControl & UnsetEverything();
21063 
21064 
21069  bool ShowSubwindow(Rectangle & out_subwindow_position, Subwindow::Type & out_subwindow_type) const;
21070 
21075  bool ShowBackground(Subwindow::Background & out_bg_type, UTF8 & out_definition_name) const;
21076 
21080  bool ShowBorder(Subwindow::Border & out_border_type) const;
21081 
21085  bool ShowRenderingAlgorithm(Subwindow::RenderingAlgorithm & out_hsra) const;
21086 
21092  bool ShowModelCompareMode(bool & out_state, SegmentKey & out_source1, SegmentKey & out_source2) const;
21093 
21094 private:
21096  SubwindowControl();
21097 };
21098 
21099 
21100 
21102 class HPS_API DebuggingKit : public Object
21103 {
21104 public:
21105 
21107  DebuggingKit();
21108 
21110  DebuggingKit(DebuggingKit const & in_kit);
21111 
21115  DebuggingKit(DebuggingKit && in_that);
21116 
21120  DebuggingKit & operator=(DebuggingKit && in_that);
21121 
21123  virtual ~DebuggingKit();
21124 
21125  HPS::Type ObjectType() const {return HPS::Type::DebuggingKit;}
21126 
21130  static DebuggingKit GetDefault();
21131 
21134  void Set(DebuggingKit const & in_kit);
21135 
21138  void Show(DebuggingKit & out_kit) const;
21139 
21143  DebuggingKit & operator=(DebuggingKit const & in_kit);
21144 
21147  bool Empty() const;
21148 
21152  bool Equals(DebuggingKit const & in_kit) const;
21153 
21157  bool operator==(DebuggingKit const & in_kit) const;
21158 
21162  bool operator!=(DebuggingKit const & in_kit) const;
21163 
21164 
21168  DebuggingKit & SetResourceMonitor(bool in_display);
21169 
21170 
21173  DebuggingKit & UnsetResourceMonitor();
21174 
21177  DebuggingKit & UnsetEverything();
21178 
21179 
21183  bool ShowResourceMonitor(bool & out_display) const;
21184 };
21185 
21186 
21189 class HPS_API DebuggingControl : public Control
21190 {
21191 public:
21192 
21194  explicit DebuggingControl(WindowKey & in_window);
21195 
21197  DebuggingControl(DebuggingControl const & in_that);
21198 
21202  DebuggingControl(DebuggingControl && in_that);
21203 
21207  DebuggingControl & operator=(DebuggingControl && in_that);
21208 
21210  ~DebuggingControl();
21211 
21212  HPS::Type ObjectType() const {return HPS::Type::DebuggingControl;}
21213 
21217  DebuggingControl & operator=(DebuggingControl const & in_that);
21218 
21223  DebuggingControl & SetResourceMonitor(bool in_display);
21224 
21228  bool ShowResourceMonitor(bool & out_display) const;
21229 
21230 private:
21232  DebuggingControl();
21233 };
21234 
21235 
21237 class HPS_API WindowInfoKit : public Object
21238 {
21239 public:
21240 
21242  WindowInfoKit();
21243 
21245  WindowInfoKit(WindowInfoKit const & in_kit);
21246 
21250  WindowInfoKit(WindowInfoKit && in_that);
21251 
21255  WindowInfoKit & operator=(WindowInfoKit && in_that);
21256 
21258  virtual ~WindowInfoKit();
21259 
21260  HPS::Type ObjectType() const {return HPS::Type::WindowInfoKit;}
21261 
21264  void Set(WindowInfoKit const & in_kit);
21265 
21268  void Show(WindowInfoKit & out_kit) const;
21269 
21273  WindowInfoKit & operator=(WindowInfoKit const & in_kit);
21274 
21277  bool Empty() const;
21278 
21282  bool Equals(WindowInfoKit const & in_kit) const;
21283 
21287  bool operator==(WindowInfoKit const & in_kit) const;
21288 
21292  bool operator!=(WindowInfoKit const & in_kit) const;
21293 
21294 
21299  WindowInfoKit & SetPhysicalPixels(unsigned int in_width, unsigned int in_height);
21300 
21305  WindowInfoKit & SetPhysicalSize(float in_width, float in_height);
21306 
21311  WindowInfoKit & SetWindowPixels(unsigned int in_width, unsigned int in_height);
21312 
21317  WindowInfoKit & SetWindowSize(float in_width, float in_height);
21318 
21319 
21322  WindowInfoKit & UnsetPhysicalPixels();
21323 
21326  WindowInfoKit & UnsetPhysicalSize();
21327 
21330  WindowInfoKit & UnsetWindowPixels();
21331 
21334  WindowInfoKit & UnsetWindowSize();
21335 
21338  WindowInfoKit & UnsetEverything();
21339 
21340 
21345  bool ShowPhysicalPixels(unsigned int & out_width, unsigned int & out_height) const;
21346 
21351  bool ShowPhysicalSize(float & out_width, float & out_height) const;
21352 
21357  bool ShowWindowPixels(unsigned int & out_width, unsigned int & out_height) const;
21358 
21363  bool ShowWindowSize(float & out_width, float & out_height) const;
21364 
21370  bool ShowResolution(float & out_horizontal, float & out_vertical) const;
21371 
21375  bool ShowWindowAspectRatio(float & out_window_aspect) const;
21376 
21380  bool ShowPixelAspectRatio(float & out_pixel_aspect) const;
21381 };
21382 
21383 
21386 class HPS_API WindowInfoControl : public Control
21387 {
21388 public:
21389 
21391  explicit WindowInfoControl(WindowKey & in_window);
21392 
21394  WindowInfoControl(WindowInfoControl const & in_that);
21395 
21400 
21404  WindowInfoControl & operator=(WindowInfoControl && in_that);
21405 
21407  ~WindowInfoControl();
21408 
21409  HPS::Type ObjectType() const {return HPS::Type::WindowInfoControl;}
21410 
21414  WindowInfoControl & operator=(WindowInfoControl const & in_that);
21415 
21420  bool ShowPhysicalPixels(unsigned int & out_width, unsigned int & out_height) const;
21421 
21426  bool ShowPhysicalSize(float & out_width, float & out_height) const;
21427 
21432  bool ShowWindowPixels(unsigned int & out_width, unsigned int & out_height) const;
21433 
21438  bool ShowWindowSize(float & out_width, float & out_height) const;
21439 
21445  bool ShowResolution(float & out_horizontal, float & out_vertical) const;
21446 
21450  bool ShowWindowAspectRatio(float & out_window_aspect) const;
21451 
21455  bool ShowPixelAspectRatio(float & out_pixel_aspect) const;
21456 
21461  bool ShowMaxTextureSize(unsigned int & out_width, unsigned int & out_height) const;
21462 
21467  bool ShowLastUpdateTime(Time & out_time) const;
21468 
21472  bool ShowDepthPeelingLayers(size_t & out_layers) const;
21473 
21477  bool ShowVideoMemory(size_t & out_video_memory) const;
21478 
21482  bool ShowDepthBufferSize(size_t & out_bits) const;
21483 
21487  bool ShowMaxLights(size_t & out_lights) const;
21488 
21492  bool ShowColorBitPlanes(size_t & out_planes) const;
21493 
21497  bool ShowLastUpdateInfo(UpdateInfo & out_info) const;
21498 
21499 private:
21502 };
21503 
21505 class HPS_API FontInfoState : public Object
21506 {
21507 public:
21508 
21510  FontInfoState();
21511 
21513  FontInfoState(FontInfoState const & in_kit);
21514 
21518  FontInfoState(FontInfoState && in_that);
21519 
21523  FontInfoState & operator=(FontInfoState && in_that);
21524 
21526  virtual ~FontInfoState();
21527 
21528  HPS::Type ObjectType() const {return HPS::Type::FontInfoState;}
21529 
21532  void Assign(FontInfoState const & in_that);
21533 
21536  void Set(FontInfoState const & in_kit);
21537 
21540  void Show(FontInfoState & out_kit) const;
21541 
21545  FontInfoState & operator=(FontInfoState const & in_kit);
21546 
21549  bool Empty() const;
21550 
21554  bool Equals(FontInfoState const & in_kit) const;
21555 
21559  bool operator==(FontInfoState const & in_kit) const;
21560 
21564  bool operator!=(FontInfoState const & in_kit) const;
21565 
21568  UTF8 GetName() const;
21569 
21572  bool GetShellConvertibility() const;
21573 };
21574 
21575 
21580 class HPS_API AttributeLockKit : public Object
21581 {
21582 public:
21583 
21585  AttributeLockKit();
21586 
21588  AttributeLockKit(AttributeLockKit const & in_kit);
21589 
21593  AttributeLockKit(AttributeLockKit && in_that);
21594 
21598  AttributeLockKit & operator=(AttributeLockKit && in_that);
21599 
21601  virtual ~AttributeLockKit();
21602 
21603  HPS::Type ObjectType() const {return HPS::Type::AttributeLockKit;}
21604 
21608  static AttributeLockKit GetDefault();
21609 
21612  void Set(AttributeLockKit const & in_kit);
21613 
21616  void Show(AttributeLockKit & out_kit) const;
21617 
21621  AttributeLockKit & operator=(AttributeLockKit const & in_kit);
21622 
21625  bool Empty() const;
21626 
21630  bool Equals(AttributeLockKit const & in_kit) const;
21631 
21635  bool operator==(AttributeLockKit const & in_kit) const;
21636 
21640  bool operator!=(AttributeLockKit const & in_kit) const;
21641 
21647  AttributeLockKit & SetLock(AttributeLock::Type in_type, bool in_state = true);
21648 
21653  AttributeLockKit & SetLock(AttributeLockTypeArray const & in_types, BoolArray const & in_states);
21654 
21660  AttributeLockKit & SetSubsegmentLockOverride(AttributeLock::Type in_type, bool in_state = true);
21661 
21667  AttributeLockKit & SetSubsegmentLockOverride(AttributeLockTypeArray const & in_types, BoolArray const & in_states);
21668 
21669 
21672  AttributeLockKit & UnsetLock(AttributeLock::Type in_type = AttributeLock::Type::Everything);
21673 
21676  AttributeLockKit & UnsetLock(AttributeLockTypeArray const & in_types);
21677 
21680  AttributeLockKit & UnsetSubsegmentLockOverride(AttributeLock::Type in_type = AttributeLock::Type::Everything);
21681 
21684  AttributeLockKit & UnsetSubsegmentLockOverride(AttributeLockTypeArray const & in_types);
21685 
21688  AttributeLockKit & UnsetEverything();
21689 
21690 
21695  bool ShowLock(AttributeLock::Type in_type, bool & out_state) const;
21696 
21701  bool ShowLock(AttributeLockTypeArray & out_types, BoolArray & out_states) const;
21702 
21707  bool ShowSubsegmentLockOverride(AttributeLock::Type in_type, bool & out_state) const;
21708 
21713  bool ShowSubsegmentLockOverride(AttributeLockTypeArray & out_types, BoolArray & out_states) const;
21714 };
21715 
21716 
21721 class HPS_API AttributeLockControl : public Control
21722 {
21723 public:
21724 
21726  explicit AttributeLockControl(SegmentKey & in_seg);
21727 
21732 
21736  AttributeLockControl & operator=(AttributeLockControl && in_that);
21737 
21739  AttributeLockControl(AttributeLockControl const & in_that);
21740 
21743 
21744  HPS::Type ObjectType() const {return HPS::Type::AttributeLockControl;}
21745 
21749  AttributeLockControl & operator=(AttributeLockControl const & in_that);
21750 
21756  AttributeLockControl & SetLock(AttributeLock::Type in_type, bool in_state = true);
21757 
21762  AttributeLockControl & SetLock(AttributeLockTypeArray const & in_types, BoolArray const & in_states);
21763 
21769  AttributeLockControl & SetSubsegmentLockOverride(AttributeLock::Type in_type, bool in_state = true);
21770 
21776  AttributeLockControl & SetSubsegmentLockOverride(AttributeLockTypeArray const & in_types, BoolArray const & in_states);
21777 
21778 
21781  AttributeLockControl & UnsetLock(AttributeLock::Type in_type = AttributeLock::Type::Everything);
21782 
21785  AttributeLockControl & UnsetLock(AttributeLockTypeArray const & in_types);
21786 
21789  AttributeLockControl & UnsetSubsegmentLockOverride(AttributeLock::Type in_type = AttributeLock::Type::Everything);
21790 
21793  AttributeLockControl & UnsetSubsegmentLockOverride(AttributeLockTypeArray const & in_types);
21794 
21797  AttributeLockControl & UnsetEverything();
21798 
21799 
21804  bool ShowLock(AttributeLock::Type in_type, bool & out_state) const;
21805 
21810  bool ShowLock(AttributeLockTypeArray & out_types, BoolArray & out_states) const;
21811 
21816  bool ShowSubsegmentLockOverride(AttributeLock::Type in_type, bool & out_state) const;
21817 
21822  bool ShowSubsegmentLockOverride(AttributeLockTypeArray & out_types, BoolArray & out_states) const;
21823 
21824 private:
21827 };
21828 
21832 
21833 class HPS_API GeometryKey : public Key
21834 {
21835 public:
21837  GeometryKey();
21838 
21842  explicit GeometryKey(Key const & in_that);
21843 
21846  GeometryKey(GeometryKey const & in_that);
21847 
21851  GeometryKey & operator=(GeometryKey const & in_that);
21852 
21856  GeometryKey(GeometryKey && in_that);
21857 
21861  GeometryKey & operator=(GeometryKey && in_that);
21862 
21863  ~GeometryKey();
21864 
21865  HPS::Type ObjectType() const { return HPS::Type::GeometryKey; };
21866 
21867 
21871  size_t ShowReferrers(SegmentKeyArray & out_segments) const;
21872 
21876  size_t ShowReferrers(ReferenceKeyArray & out_references) const;
21877 
21878 
21879 
21886  GeometryKey & SetPriority(int in_priority);
21887 
21890  GeometryKey & UnsetPriority();
21891 
21895  bool ShowPriority(int & out_priority) const;
21896 
21897 
21903  GeometryKey & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
21904 
21909  GeometryKey & SetUserData(intptr_t in_index, ByteArray const & in_data);
21910 
21915  GeometryKey & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
21916 
21920  GeometryKey & UnsetUserData(intptr_t in_index);
21921 
21926  GeometryKey & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
21927 
21931  GeometryKey & UnsetUserData(IntPtrTArray const & in_indices);
21932 
21935  GeometryKey & UnsetAllUserData();
21936 
21938  size_t ShowUserDataCount() const;
21939 
21943  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
21944 
21949  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
21950 
21955  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
21956 
21961  bool ShowBoundings(BoundingKit & out_kit) const;
21962 };
21963 
21964 
21966 class HPS_API LineKit : public Object
21967 {
21968 public:
21970  LineKit();
21971 
21974  LineKit(LineKit const & in_kit);
21975 
21979  LineKit(LineKit && in_that);
21980 
21984  LineKit & operator=(LineKit && in_that);
21985 
21986  virtual ~LineKit();
21987 
21988  HPS::Type ObjectType() const { return HPS::Type::LineKit; };
21989 
21992  void Consume(LineKit & in_kit);
21993 
21996  void Set(LineKit const & in_kit);
21997 
22000  void Show(LineKit & out_kit) const;
22001 
22005  LineKit & operator=(LineKit const & in_kit);
22006 
22009  bool Empty() const;
22010 
22014  bool Equals(LineKit const & in_kit) const;
22015 
22019  bool operator==(LineKit const & in_kit) const;
22020 
22024  bool operator!=(LineKit const & in_kit) const;
22025 
22028  size_t GetPointCount() const;
22029 
22036  LineKit & SetPriority(int in_priority);
22037 
22040  LineKit & UnsetPriority();
22041 
22045  bool ShowPriority(int & out_priority) const;
22046 
22047 
22051  LineKit & SetPoints(PointArray const & in_points);
22052 
22057  LineKit & SetPoints(size_t in_count, Point const in_points []);
22058 
22059 
22062  LineKit & UnsetPoints();
22063 
22066  LineKit & UnsetEverything();
22067 
22068 
22072  bool ShowPoints(PointArray & out_points) const;
22073 
22079  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
22080 
22085  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
22086 
22092  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
22093 
22094 
22100  LineKit & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
22101 
22106  LineKit & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
22107 
22112  LineKit & EditPointsByDeletion(size_t in_offset, size_t in_count);
22113 
22119  LineKit & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
22120 
22126  LineKit & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
22127 
22133  LineKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
22134 
22139  LineKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
22140 
22145  LineKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
22146 
22150  LineKit & UnsetUserData(intptr_t in_index);
22151 
22156  LineKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
22157 
22161  LineKit & UnsetUserData(IntPtrTArray const & in_indices);
22162 
22165  LineKit & UnsetAllUserData();
22166 
22168  size_t ShowUserDataCount() const;
22169 
22173  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
22174 
22179  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
22180 
22185  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
22186 };
22187 
22189 class HPS_API LineKey : public GeometryKey
22190 {
22191 public:
22193  LineKey();
22194 
22198  explicit LineKey(Key const & in_that);
22199 
22202  LineKey(LineKey const & in_that);
22203 
22207  LineKey & operator=(LineKey const & in_that);
22208 
22212  LineKey(LineKey && in_that);
22213 
22217  LineKey & operator=(LineKey && in_that);
22218 
22219  ~LineKey();
22220 
22221  HPS::Type ObjectType() const { return HPS::Type::LineKey; };
22222 
22223 
22226  void Consume(LineKit & in_kit);
22227 
22230  void Set(LineKit const & in_kit);
22231 
22234  void Show(LineKit & out_kit) const;
22235 
22238  size_t GetPointCount() const;
22239 
22243  LineKey & SetPoints(PointArray const & in_points);
22244 
22249  LineKey & SetPoints(size_t in_count, Point const in_points []);
22250 
22251 
22255  bool ShowPoints(PointArray & out_points) const;
22256 
22262  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
22263 
22268  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
22269 
22275  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
22276 
22277 
22283  LineKey & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
22284 
22289  LineKey & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
22290 
22295  LineKey & EditPointsByDeletion(size_t in_offset, size_t in_count);
22296 
22302  LineKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
22303 
22309  LineKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
22310 };
22311 
22312 
22313 
22315 class HPS_API MarkerKit : public Object
22316 {
22317 public:
22319  MarkerKit();
22320 
22323  MarkerKit(MarkerKit const & in_kit);
22324 
22328  MarkerKit(MarkerKit && in_that);
22329 
22333  MarkerKit & operator=(MarkerKit && in_that);
22334 
22335  virtual ~MarkerKit();
22336 
22337  HPS::Type ObjectType() const { return HPS::Type::MarkerKit; };
22338 
22341  void Consume(MarkerKit & in_kit);
22342 
22345  void Set(MarkerKit const & in_kit);
22346 
22349  void Show(MarkerKit & out_kit) const;
22350 
22354  MarkerKit & operator=(MarkerKit const & in_kit);
22355 
22358  bool Empty() const;
22359 
22363  bool Equals(MarkerKit const & in_kit) const;
22364 
22368  bool operator==(MarkerKit const & in_kit) const;
22369 
22373  bool operator!=(MarkerKit const & in_kit) const;
22374 
22375 
22382  MarkerKit & SetPriority(int in_priority);
22383 
22386  MarkerKit & UnsetPriority();
22387 
22391  bool ShowPriority(int & out_priority) const;
22392 
22396  MarkerKit & SetPoint(Point const & in_point);
22397 
22398 
22401  MarkerKit & UnsetPoint();
22402 
22405  MarkerKit & UnsetEverything();
22406 
22407 
22411  bool ShowPoint(HPS::Point & out_point) const;
22412 
22418  MarkerKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
22419 
22424  MarkerKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
22425 
22430  MarkerKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
22431 
22435  MarkerKit & UnsetUserData(intptr_t in_index);
22436 
22441  MarkerKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
22442 
22446  MarkerKit & UnsetUserData(IntPtrTArray const & in_indices);
22447 
22450  MarkerKit & UnsetAllUserData();
22451 
22453  size_t ShowUserDataCount() const;
22454 
22458  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
22459 
22464  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
22465 
22470  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
22471 };
22472 
22474 class HPS_API MarkerKey : public GeometryKey
22475 {
22476 public:
22478  MarkerKey();
22479 
22483  explicit MarkerKey(Key const & in_that);
22484 
22487  MarkerKey(MarkerKey const & in_that);
22488 
22492  MarkerKey & operator=(MarkerKey const & in_that);
22493 
22497  MarkerKey(MarkerKey && in_that);
22498 
22502  MarkerKey & operator=(MarkerKey && in_that);
22503 
22504  ~MarkerKey();
22505 
22506  HPS::Type ObjectType() const { return HPS::Type::MarkerKey; };
22507 
22508 
22511  void Consume(MarkerKit & in_kit);
22512 
22515  void Set(MarkerKit const & in_kit);
22516 
22519  void Show(MarkerKit & out_kit) const;
22520 
22521 
22525  MarkerKey & SetPoint(Point const & in_point);
22526 
22530  bool ShowPoint(Point & out_point) const;
22531 };
22532 
22533 
22534 
22536 class HPS_API DistantLightKit : public Object
22537 {
22538 public:
22540  DistantLightKit();
22541 
22544  DistantLightKit(DistantLightKit const & in_kit);
22545 
22549  DistantLightKit(DistantLightKit && in_that);
22550 
22554  DistantLightKit & operator=(DistantLightKit && in_that);
22555 
22556  virtual ~DistantLightKit();
22557 
22558  HPS::Type ObjectType() const { return HPS::Type::DistantLightKit; };
22559 
22562  void Consume(DistantLightKit & in_kit);
22563 
22566  void Set(DistantLightKit const & in_kit);
22567 
22570  void Show(DistantLightKit & out_kit) const;
22571 
22575  DistantLightKit & operator=(DistantLightKit const & in_kit);
22576 
22579  bool Empty() const;
22580 
22584  bool Equals(DistantLightKit const & in_kit) const;
22585 
22589  bool operator==(DistantLightKit const & in_kit) const;
22590 
22594  bool operator!=(DistantLightKit const & in_kit) const;
22595 
22596 
22603  DistantLightKit & SetPriority(int in_priority);
22604 
22610  DistantLightKit & SetDirection(HPS::Vector const & in_vector);
22611 
22615  DistantLightKit & SetColor(RGBAColor const & in_rgba_color);
22616 
22620  DistantLightKit & SetColorByIndex(float in_index);
22621 
22627  DistantLightKit & SetCameraRelative(bool in_state);
22628 
22629 
22632  DistantLightKit & UnsetPriority();
22633 
22636  DistantLightKit & UnsetDirection();
22637 
22640  DistantLightKit & UnsetColor();
22641 
22644  DistantLightKit & UnsetCameraRelative();
22645 
22648  DistantLightKit & UnsetEverything();
22649 
22650 
22654  bool ShowPriority(int & out_priority) const;
22655 
22659  bool ShowDirection(HPS::Vector & out_vector) const;
22660 
22666  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
22667 
22671  bool ShowCameraRelative(bool & out_state) const;
22672 
22678  DistantLightKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
22679 
22684  DistantLightKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
22685 
22690  DistantLightKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
22691 
22695  DistantLightKit & UnsetUserData(intptr_t in_index);
22696 
22701  DistantLightKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
22702 
22706  DistantLightKit & UnsetUserData(IntPtrTArray const & in_indices);
22707 
22710  DistantLightKit & UnsetAllUserData();
22711 
22713  size_t ShowUserDataCount() const;
22714 
22718  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
22719 
22724  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
22725 
22730  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
22731 };
22732 
22733 
22734 
22736 class HPS_API DistantLightKey : public GeometryKey
22737 {
22738 public:
22740  DistantLightKey();
22741 
22745  explicit DistantLightKey(Key const & in_that);
22746 
22749  DistantLightKey(DistantLightKey const & in_that);
22750 
22754  DistantLightKey & operator=(DistantLightKey const & in_that);
22755 
22759  DistantLightKey(DistantLightKey && in_that);
22760 
22764  DistantLightKey & operator=(DistantLightKey && in_that);
22765 
22766  ~DistantLightKey();
22767 
22768  HPS::Type ObjectType() const { return HPS::Type::DistantLightKey; };
22769 
22772  void Consume(DistantLightKit & in_kit);
22773 
22776  void Set(DistantLightKit const & in_kit);
22777 
22780  void Show(DistantLightKit & out_kit) const;
22781 
22786  DistantLightKey & SetDirection(HPS::Vector const & in_vector);
22787 
22791  DistantLightKey & SetColor(RGBAColor const & in_rgba_color);
22792 
22796  DistantLightKey & SetColorByIndex(float in_index);
22797 
22802  DistantLightKey & SetCameraRelative(bool in_state);
22803 
22804 
22807  DistantLightKey & UnsetColor();
22808 
22809 
22813  bool ShowDirection(HPS::Vector & out_vector) const;
22814 
22820  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
22821 
22825  bool ShowCameraRelative(bool & out_state) const;
22826 };
22827 
22828 
22829 
22830 
22832 class HPS_API CylinderKit : public Object
22833 {
22834 public:
22836  CylinderKit();
22837 
22840  CylinderKit(CylinderKit const & in_kit);
22841 
22845  CylinderKit(CylinderKit && in_that);
22846 
22850  CylinderKit & operator=(CylinderKit && in_that);
22851 
22852  virtual ~CylinderKit();
22853 
22854  HPS::Type ObjectType() const { return HPS::Type::CylinderKit; };
22855 
22858  void Consume(CylinderKit & in_kit);
22859 
22862  void Set(CylinderKit const & in_kit);
22863 
22866  void Show(CylinderKit & out_kit) const;
22867 
22871  CylinderKit & operator=(CylinderKit const & in_kit);
22872 
22875  bool Empty() const;
22876 
22880  bool Equals(CylinderKit const & in_kit) const;
22881 
22885  bool operator==(CylinderKit const & in_kit) const;
22886 
22890  bool operator!=(CylinderKit const & in_kit) const;
22891 
22894  size_t GetPointCount() const;
22895 
22902  CylinderKit & SetPriority(int in_priority);
22903 
22906  CylinderKit & UnsetPriority();
22907 
22911  bool ShowPriority(int & out_priority) const;
22912 
22913 
22917  CylinderKit & SetPoints(PointArray const & in_points);
22918 
22923  CylinderKit & SetPoints(size_t in_count, Point const in_points []);
22924 
22928  CylinderKit & SetRadii(FloatArray const & in_radii);
22929 
22934  CylinderKit & SetRadii(size_t in_count, float const in_radii []);
22935 
22939  CylinderKit & SetCaps(Cylinder::Capping in_capping);
22940 
22941 
22944  CylinderKit & UnsetPoints();
22945 
22948  CylinderKit & UnsetRadii();
22949 
22952  CylinderKit & UnsetCaps();
22953 
22956  CylinderKit & UnsetEverything();
22957 
22958 
22962  bool ShowPoints(PointArray & out_points) const;
22963 
22969  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
22970 
22975  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
22976 
22982  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
22983 
22987  bool ShowRadii(FloatArray & out_radii) const;
22988 
22992  bool ShowCaps(Cylinder::Capping & out_caps) const;
22993 
22994 
23001  CylinderKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23002 
23008  CylinderKit & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23009 
23016  CylinderKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23017 
23024  CylinderKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23025 
23032  CylinderKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23033 
23040  CylinderKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23041 
23047  CylinderKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23048 
23049 
23056  CylinderKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23057 
23063  CylinderKit & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23064 
23071  CylinderKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23072 
23079  CylinderKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23080 
23087  CylinderKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23088 
23095  CylinderKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23096 
23102  CylinderKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23103 
23104 
23107  CylinderKit & UnsetVertexColors();
23108 
23113  CylinderKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
23114 
23118  CylinderKit & UnsetVertexColorsByList(SizeTArray const & in_vertices);
23119 
23120 
23124  CylinderKit & UnsetVertexColors(Cylinder::Component in_apply_to);
23125 
23131  CylinderKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Cylinder::Component in_apply_to);
23132 
23137  CylinderKit & UnsetVertexColorsByList(SizeTArray const & in_vertices, Cylinder::Component in_apply_to);
23138 
23139 
23151  bool ShowVertexColorsByRange(size_t in_start, size_t in_count, Cylinder::Component in_apply_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
23152 
23165  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Cylinder::Component in_apply_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
23166 
23172  CylinderKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
23173 
23178  CylinderKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
23179 
23184  CylinderKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
23185 
23189  CylinderKit & UnsetUserData(intptr_t in_index);
23190 
23195  CylinderKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
23196 
23200  CylinderKit & UnsetUserData(IntPtrTArray const & in_indices);
23201 
23204  CylinderKit & UnsetAllUserData();
23205 
23207  size_t ShowUserDataCount() const;
23208 
23212  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
23213 
23218  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
23219 
23224  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
23225 };
23226 
23227 
23228 
23230 class HPS_API CylinderKey : public GeometryKey
23231 {
23232 public:
23234  CylinderKey();
23235 
23239  explicit CylinderKey(Key const & in_that);
23240 
23243  CylinderKey(CylinderKey const & in_that);
23244 
23248  CylinderKey & operator=(CylinderKey const & in_that);
23249 
23253  CylinderKey(CylinderKey && in_that);
23254 
23258  CylinderKey & operator=(CylinderKey && in_that);
23259 
23260  ~CylinderKey();
23261 
23262  HPS::Type ObjectType() const { return HPS::Type::CylinderKey; };
23263 
23266  void Consume(CylinderKit & in_kit);
23267 
23270  void Set(CylinderKit const & in_kit);
23271 
23272 
23278  CylinderKey & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
23279 
23284  CylinderKey & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
23285 
23290  CylinderKey & EditPointsByDeletion(size_t in_offset, size_t in_count);
23291 
23297  CylinderKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
23298 
23304  CylinderKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
23305 
23306 
23312  CylinderKey & EditRadiiByInsertion(size_t in_offset, size_t in_count, float const in_radii[]);
23313 
23318  CylinderKey & EditRadiiByInsertion(size_t in_offset, FloatArray const & in_radii);
23319 
23324  CylinderKey & EditRadiiByDeletion(size_t in_offset, size_t in_count);
23325 
23331  CylinderKey & EditRadiiByReplacement(size_t in_offset, size_t in_count, float const in_radii[]);
23332 
23338  CylinderKey & EditRadiiByReplacement(size_t in_offset, FloatArray const & in_radii);
23339 
23340 
23343  void Show(CylinderKit & out_kit) const;
23344 
23347  size_t GetPointCount() const;
23348 
23352  bool ShowPoints(PointArray & out_points) const;
23353 
23359  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
23360 
23365  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
23366 
23372  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
23373 
23377  bool ShowRadii(FloatArray & out_radii) const;
23378 
23382  bool ShowCaps(Cylinder::Capping & out_caps) const;
23383 
23384 
23391  CylinderKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23392 
23399  CylinderKey & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23400 
23407  CylinderKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23408 
23409 
23416  CylinderKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23417 
23424  CylinderKey & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23425 
23432  CylinderKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23433 
23434 
23437  CylinderKey & UnsetVertexColors();
23438 
23443  CylinderKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
23444 
23448  CylinderKey & UnsetVertexColors(Cylinder::Component in_apply_to);
23449 
23455  CylinderKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Cylinder::Component in_apply_to);
23456 
23457 
23469  bool ShowVertexColorsByRange(size_t in_start, size_t in_count, Cylinder::Component in_apply_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
23470 
23483  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Cylinder::Component in_apply_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
23484 };
23485 
23486 
23487 
23488 
23490 class HPS_API SphereKit : public Object
23491 {
23492 public:
23494  SphereKit();
23495 
23498  SphereKit(SphereKit const & in_kit);
23499 
23503  SphereKit(SphereKit && in_that);
23504 
23508  SphereKit & operator=(SphereKit && in_that);
23509 
23510  virtual ~SphereKit();
23511 
23512  HPS::Type ObjectType() const { return HPS::Type::SphereKit; };
23513 
23516  void Consume(SphereKit & in_kit);
23517 
23520  void Set(SphereKit const & in_kit);
23521 
23524  void Show(SphereKit & out_kit) const;
23525 
23529  SphereKit & operator=(SphereKit const & in_kit);
23530 
23533  bool Empty() const;
23534 
23538  bool Equals(SphereKit const & in_kit) const;
23539 
23543  bool operator==(SphereKit const & in_kit) const;
23544 
23548  bool operator!=(SphereKit const & in_kit) const;
23549 
23556  SphereKit & SetPriority(int in_priority);
23557 
23560  SphereKit & UnsetPriority();
23561 
23565  bool ShowPriority(int & out_priority) const;
23566 
23570  SphereKit & SetCenter(Point const & in_center);
23571 
23575  SphereKit & SetRadius(float in_radius);
23576 
23581  SphereKit & SetBasis(Vector const & in_vertical, Vector const & in_horizontal);
23582 
23583 
23586  SphereKit & UnsetCenter();
23587 
23590  SphereKit & UnsetRadius();
23591 
23594  SphereKit & UnsetBasis();
23595 
23598  SphereKit & UnsetEverything();
23599 
23600 
23604  bool ShowCenter(Point & out_center) const;
23605 
23609  bool ShowRadius(float & out_radius) const;
23610 
23615  bool ShowBasis(Vector & out_vertical, Vector & out_horizontal) const;
23616 
23622  SphereKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
23623 
23628  SphereKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
23629 
23634  SphereKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
23635 
23639  SphereKit & UnsetUserData(intptr_t in_index);
23640 
23645  SphereKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
23646 
23650  SphereKit & UnsetUserData(IntPtrTArray const & in_indices);
23651 
23654  SphereKit & UnsetAllUserData();
23655 
23657  size_t ShowUserDataCount() const;
23658 
23662  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
23663 
23668  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
23669 
23674  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
23675 };
23676 
23678 class HPS_API SphereKey : public GeometryKey
23679 {
23680 public:
23682  SphereKey();
23683 
23687  explicit SphereKey(Key const & in_that);
23688 
23691  SphereKey(SphereKey const & in_that);
23692 
23696  SphereKey & operator=(SphereKey const & in_that);
23697 
23701  SphereKey(SphereKey && in_that);
23702 
23706  SphereKey & operator=(SphereKey && in_that);
23707 
23708  ~SphereKey();
23709 
23710  HPS::Type ObjectType() const {return HPS::Type::SphereKey;};
23711 
23714  void Consume(SphereKit & in_kit);
23715 
23718  void Set(SphereKit const & in_kit);
23719 
23722  void Show(SphereKit & out_kit) const;
23723 
23724 
23728  SphereKey & SetCenter(Point const & in_center);
23729 
23733  SphereKey & SetRadius(float in_radius);
23734 
23739  SphereKey & SetBasis(Vector const & in_vertical, Vector const & in_horizontal);
23740 
23741 
23745  bool ShowCenter(Point & out_center) const;
23746 
23750  bool ShowRadius(float & out_radius) const;
23751 
23756  bool ShowBasis(Vector & out_vertical, Vector & out_horizontal) const;
23757 };
23758 
23759 
23760 
23761 
23763 class HPS_API CircleKit : public Object
23764 {
23765 public:
23767  CircleKit();
23768 
23771  CircleKit(CircleKit const & in_kit);
23772 
23776  CircleKit(CircleKit && in_that);
23777 
23781  CircleKit & operator=(CircleKit && in_that);
23782 
23783  virtual ~CircleKit();
23784 
23785  HPS::Type ObjectType() const { return HPS::Type::CircleKit; };
23786 
23789  void Consume(CircleKit & in_kit);
23790 
23793  void Set(CircleKit const & in_kit);
23794 
23797  void Show(CircleKit & out_kit) const;
23798 
23802  CircleKit & operator=(CircleKit const & in_kit);
23803 
23806  bool Empty() const;
23807 
23811  bool Equals(CircleKit const & in_kit) const;
23812 
23816  bool operator==(CircleKit const & in_kit) const;
23817 
23821  bool operator!=(CircleKit const & in_kit) const;
23822 
23829  CircleKit & SetPriority(int const in_priority);
23830 
23833  CircleKit & UnsetPriority();
23834 
23838  bool ShowPriority(int & out_priority) const;
23839 
23840 
23841 
23845  CircleKit & SetCenter(Point const & in_center);
23846 
23850  CircleKit & SetRadius(float in_radius);
23851 
23855  CircleKit & SetNormal(Vector const & in_normal);
23856 
23857 
23860  CircleKit & UnsetCenter();
23861 
23864  CircleKit & UnsetRadius();
23865 
23868  CircleKit & UnsetNormal();
23869 
23872  CircleKit & UnsetEverything();
23873 
23874 
23878  bool ShowCenter(Point & out_center) const;
23879 
23883  bool ShowRadius(float & out_radius) const;
23884 
23888  bool ShowNormal(Vector & out_normal) const;
23889 
23895  CircleKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
23896 
23901  CircleKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
23902 
23907  CircleKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
23908 
23912  CircleKit & UnsetUserData(intptr_t in_index);
23913 
23918  CircleKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
23919 
23923  CircleKit & UnsetUserData(IntPtrTArray const & in_indices);
23924 
23927  CircleKit & UnsetAllUserData();
23928 
23930  size_t ShowUserDataCount() const;
23931 
23935  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
23936 
23941  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
23942 
23947  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
23948 };
23949 
23950 
23953 class HPS_API CircleKey : public GeometryKey
23954 {
23955 public:
23957  CircleKey();
23958 
23962  explicit CircleKey(Key const & in_that);
23963 
23966  CircleKey(CircleKey const & in_that);
23967 
23971  CircleKey & operator=(CircleKey const & in_that);
23972 
23976  CircleKey(CircleKey && in_that);
23977 
23981  CircleKey & operator=(CircleKey && in_that);
23982 
23983  ~CircleKey();
23984 
23985  HPS::Type ObjectType() const { return HPS::Type::CircleKey; };
23986 
23987 
23990  void Consume(CircleKit & in_kit);
23991 
23994  void Set(CircleKit const & in_kit);
23995 
23998  void Show(CircleKit & out_kit) const;
23999 
24000 
24004  CircleKey & SetCenter(Point const & in_center);
24005 
24009  CircleKey & SetRadius(float in_radius);
24010 
24014  CircleKey & SetNormal(Vector const & in_normal);
24015 
24016 
24020  bool ShowCenter(Point & out_center) const;
24021 
24025  bool ShowRadius(float & out_radius) const;
24026 
24030  bool ShowNormal(Vector & out_normal) const;
24031 };
24032 
24033 
24034 
24035 
24037 class HPS_API CircularArcKit : public Object
24038 {
24039 public:
24041  CircularArcKit();
24042 
24045  CircularArcKit(CircularArcKit const & in_kit);
24046 
24050  CircularArcKit(CircularArcKit && in_that);
24051 
24055  CircularArcKit & operator=(CircularArcKit && in_that);
24056 
24057  virtual ~CircularArcKit();
24058 
24059  HPS::Type ObjectType() const { return HPS::Type::CircularArcKit; };
24060 
24063  void Consume(CircularArcKit & in_kit);
24064 
24067  void Set(CircularArcKit const & in_kit);
24068 
24071  void Show(CircularArcKit & out_kit) const;
24072 
24076  CircularArcKit & operator=(CircularArcKit const & in_kit);
24077 
24080  bool Empty() const;
24081 
24085  bool Equals(CircularArcKit const & in_kit) const;
24086 
24090  bool operator==(CircularArcKit const & in_kit) const;
24091 
24095  bool operator!=(CircularArcKit const & in_kit) const;
24096 
24103  CircularArcKit & SetPriority(int in_priority);
24104 
24107  CircularArcKit & UnsetPriority();
24108 
24112  bool ShowPriority(int & out_priority) const;
24113 
24114 
24118  CircularArcKit & SetStart(Point const & in_start);
24119 
24123  CircularArcKit & SetMiddle(Point const & in_middle);
24124 
24128  CircularArcKit & SetEnd(Point const & in_end);
24129 
24130 
24133  CircularArcKit & UnsetStart();
24134 
24137  CircularArcKit & UnsetMiddle();
24138 
24141  CircularArcKit & UnsetEnd();
24142 
24145  CircularArcKit & UnsetEverything();
24146 
24147 
24151  bool ShowStart(Point & out_start) const;
24152 
24156  bool ShowMiddle(Point & out_middle) const;
24157 
24161  bool ShowEnd(Point & out_end) const;
24162 
24168  CircularArcKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
24169 
24174  CircularArcKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
24175 
24180  CircularArcKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
24181 
24185  CircularArcKit & UnsetUserData(intptr_t in_index);
24186 
24191  CircularArcKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
24192 
24196  CircularArcKit & UnsetUserData(IntPtrTArray const & in_indices);
24197 
24200  CircularArcKit & UnsetAllUserData();
24201 
24203  size_t ShowUserDataCount() const;
24204 
24208  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
24209 
24214  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
24215 
24220  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
24221 };
24222 
24225 class HPS_API CircularArcKey : public GeometryKey
24226 {
24227 public:
24229  CircularArcKey();
24230 
24234  explicit CircularArcKey(Key const & in_that);
24235 
24238  CircularArcKey(CircularArcKey const & in_that);
24239 
24243  CircularArcKey & operator=(CircularArcKey const & in_that);
24244 
24248  CircularArcKey(CircularArcKey && in_that);
24249 
24253  CircularArcKey & operator=(CircularArcKey && in_that);
24254 
24255  ~CircularArcKey();
24256 
24257  HPS::Type ObjectType() const { return HPS::Type::CircularArcKey; };
24258 
24259 
24262  void Consume(CircularArcKit & in_kit);
24263 
24266  void Set(CircularArcKit const & in_kit);
24267 
24270  void Show(CircularArcKit & out_kit) const;
24271 
24272 
24276  CircularArcKey & SetStart(Point const & in_start);
24277 
24281  CircularArcKey & SetMiddle(Point const & in_middle);
24282 
24286  CircularArcKey & SetEnd(Point const & in_end);
24287 
24288 
24292  bool ShowStart(Point & out_start) const;
24293 
24297  bool ShowMiddle(Point & out_middle) const;
24298 
24302  bool ShowEnd(Point & out_end) const;
24303 };
24304 
24305 
24306 
24308 class HPS_API CircularWedgeKit : public Object
24309 {
24310 public:
24312  CircularWedgeKit();
24313 
24316  CircularWedgeKit(CircularWedgeKit const & in_kit);
24317 
24321  CircularWedgeKit(CircularWedgeKit && in_that);
24322 
24326  CircularWedgeKit & operator=(CircularWedgeKit && in_that);
24327 
24328  virtual ~CircularWedgeKit();
24329 
24330  HPS::Type ObjectType() const { return HPS::Type::CircularWedgeKit; };
24331 
24334  void Consume(CircularWedgeKit & in_kit);
24335 
24338  void Set(CircularWedgeKit const & in_kit);
24339 
24342  void Show(CircularWedgeKit & out_kit) const;
24343 
24347  CircularWedgeKit & operator=(CircularWedgeKit const & in_kit);
24348 
24351  bool Empty() const;
24352 
24356  bool Equals(CircularWedgeKit const & in_kit) const;
24357 
24361  bool operator==(CircularWedgeKit const & in_kit) const;
24362 
24366  bool operator!=(CircularWedgeKit const & in_kit) const;
24367 
24368 
24375  CircularWedgeKit & SetPriority(int in_priority);
24376 
24379  CircularWedgeKit & UnsetPriority();
24380 
24384  bool ShowPriority(int & out_priority) const;
24385 
24386 
24390  CircularWedgeKit & SetStart(Point const & in_start);
24391 
24395  CircularWedgeKit & SetMiddle(Point const & in_middle);
24396 
24400  CircularWedgeKit & SetEnd(Point const & in_end);
24401 
24402 
24405  CircularWedgeKit & UnsetStart();
24406 
24409  CircularWedgeKit & UnsetMiddle();
24410 
24413  CircularWedgeKit & UnsetEnd();
24414 
24417  CircularWedgeKit & UnsetEverything();
24418 
24419 
24423  bool ShowStart(Point & out_start) const;
24424 
24428  bool ShowMiddle(Point & out_middle) const;
24429 
24433  bool ShowEnd(Point & out_end) const;
24434 
24440  CircularWedgeKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
24441 
24446  CircularWedgeKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
24447 
24452  CircularWedgeKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
24453 
24457  CircularWedgeKit & UnsetUserData(intptr_t in_index);
24458 
24463  CircularWedgeKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
24464 
24468  CircularWedgeKit & UnsetUserData(IntPtrTArray const & in_indices);
24469 
24472  CircularWedgeKit & UnsetAllUserData();
24473 
24475  size_t ShowUserDataCount() const;
24476 
24480  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
24481 
24486  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
24487 
24492  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
24493 };
24494 
24495 
24499 class HPS_API CircularWedgeKey : public GeometryKey
24500 {
24501 public:
24503  CircularWedgeKey();
24504 
24508  explicit CircularWedgeKey(Key const & in_that);
24509 
24512  CircularWedgeKey(CircularWedgeKey const & in_that);
24513 
24517  CircularWedgeKey & operator=(CircularWedgeKey const & in_that);
24518 
24522  CircularWedgeKey(CircularWedgeKey && in_that);
24523 
24527  CircularWedgeKey & operator=(CircularWedgeKey && in_that);
24528 
24529  ~CircularWedgeKey();
24530 
24531  HPS::Type ObjectType() const { return HPS::Type::CircularWedgeKey; };
24532 
24533 
24536  void Consume(CircularWedgeKit & in_kit);
24537 
24540  void Set(CircularWedgeKit const & in_kit);
24541 
24544  void Show(CircularWedgeKit & out_kit) const;
24545 
24546 
24550  CircularWedgeKey & SetStart(Point const & in_start);
24551 
24555  CircularWedgeKey & SetMiddle(Point const & in_middle);
24556 
24560  CircularWedgeKey & SetEnd(Point const & in_end);
24561 
24562 
24566  bool ShowStart(Point & out_start) const;
24567 
24571  bool ShowMiddle(Point & out_middle) const;
24572 
24576  bool ShowEnd(Point & out_end) const;
24577 };
24578 
24579 
24580 
24582 class HPS_API CuttingSectionKit : public Object
24583 {
24584 public:
24587 
24590  CuttingSectionKit(CuttingSectionKit const & in_kit);
24591 
24596 
24600  CuttingSectionKit & operator=(CuttingSectionKit && in_that);
24601 
24602  virtual ~CuttingSectionKit();
24603 
24604  HPS::Type ObjectType() const { return HPS::Type::CuttingSectionKit; };
24605 
24608  void Consume(CuttingSectionKit & in_kit);
24609 
24612  void Set(CuttingSectionKit const & in_kit);
24613 
24616  void Show(CuttingSectionKit & out_kit) const;
24617 
24621  CuttingSectionKit & operator=(CuttingSectionKit const & in_kit);
24622 
24625  bool Empty() const;
24626 
24630  bool Equals(CuttingSectionKit const & in_kit) const;
24631 
24635  bool operator==(CuttingSectionKit const & in_kit) const;
24636 
24640  bool operator!=(CuttingSectionKit const & in_kit) const;
24641 
24648  CuttingSectionKit & SetPriority(int in_priority);
24649 
24652  CuttingSectionKit & UnsetPriority();
24653 
24657  bool ShowPriority(int & out_priority) const;
24658 
24659 
24663  CuttingSectionKit & SetPlanes(Plane const & in_plane);
24664 
24668  CuttingSectionKit & SetPlanes(PlaneArray const & in_planes);
24669 
24674  CuttingSectionKit & SetPlanes(size_t in_count, Plane const in_planes[]);
24675 
24681  CuttingSectionKit & SetVisualization(CuttingSection::Mode in_mode, RGBAColor const & in_color, float in_scale = 1.0f);
24682 
24683 
24686  CuttingSectionKit & UnsetPlanes();
24687 
24690  CuttingSectionKit & UnsetVisualization();
24691 
24694  CuttingSectionKit & UnsetEverything();
24695 
24696 
24699  size_t GetPlaneCount() const;
24700 
24704  bool ShowPlanes(HPS::PlaneArray & out_planes) const;
24705 
24711  bool ShowVisualization(CuttingSection::Mode & out_mode, RGBAColor & out_color, float & out_scale) const;
24712 
24713 
24720  CuttingSectionKit & EditPlanesByInsertion(size_t in_offset, size_t in_count, Plane const in_planes[]);
24721 
24727  CuttingSectionKit & EditPlanesByInsertion(size_t in_offset, PlaneArray const & in_planes);
24728 
24735  CuttingSectionKit & EditPlanesByDeletion(size_t in_offset, size_t in_count);
24736 
24743  CuttingSectionKit & EditPlanesByReplacement(size_t in_offset, size_t in_count, Plane const in_planes[]);
24744 
24752  CuttingSectionKit & EditPlanesByReplacement(size_t in_offset, PlaneArray const & in_planes);
24753 
24759  CuttingSectionKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
24760 
24765  CuttingSectionKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
24766 
24771  CuttingSectionKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
24772 
24776  CuttingSectionKit & UnsetUserData(intptr_t in_index);
24777 
24782  CuttingSectionKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
24783 
24787  CuttingSectionKit & UnsetUserData(IntPtrTArray const & in_indices);
24788 
24791  CuttingSectionKit & UnsetAllUserData();
24792 
24794  size_t ShowUserDataCount() const;
24795 
24799  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
24800 
24805  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
24806 
24811  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
24812 };
24813 
24814 
24816 class HPS_API CuttingSectionKey : public GeometryKey
24817 {
24818 public:
24821 
24825  explicit CuttingSectionKey(Key const & in_that);
24826 
24829  CuttingSectionKey(CuttingSectionKey const & in_that);
24830 
24834  CuttingSectionKey & operator=(CuttingSectionKey const & in_that);
24835 
24840 
24844  CuttingSectionKey & operator=(CuttingSectionKey && in_that);
24845 
24846  ~CuttingSectionKey();
24847 
24848  HPS::Type ObjectType() const { return HPS::Type::CuttingSectionKey; };
24849 
24850 
24853  void Consume(CuttingSectionKit & in_kit);
24854 
24857  void Set(CuttingSectionKit const & in_kit);
24858 
24861  void Show(CuttingSectionKit & out_kit) const;
24862 
24863 
24867  CuttingSectionKey & SetPlanes(Plane const & in_plane);
24868 
24872  CuttingSectionKey & SetPlanes(PlaneArray const & in_planes);
24873 
24878  CuttingSectionKey & SetPlanes(size_t in_count, Plane const in_planes[]);
24879 
24885  CuttingSectionKey & SetVisualization(CuttingSection::Mode in_mode, RGBAColor const & in_color, float in_scale = 1.0f);
24886 
24887 
24890  size_t GetPlaneCount() const;
24891 
24895  bool ShowPlanes(HPS::PlaneArray & out_planes) const;
24896 
24902  bool ShowVisualization(CuttingSection::Mode & out_mode, RGBAColor & out_color, float & out_scale) const;
24903 
24904 
24911  CuttingSectionKey & EditPlanesByInsertion(size_t in_offset, size_t in_count, Plane const in_planes[]);
24912 
24918  CuttingSectionKey & EditPlanesByInsertion(size_t in_offset, PlaneArray const & in_planes);
24919 
24926  CuttingSectionKey & EditPlanesByDeletion(size_t in_offset, size_t in_count);
24927 
24934  CuttingSectionKey & EditPlanesByReplacement(size_t in_offset, size_t in_count, Plane const in_planes[]);
24935 
24941  CuttingSectionKey & EditPlanesByReplacement(size_t in_offset, PlaneArray const & in_planes);
24942 };
24943 
24944 
24945 
24947 class HPS_API InfiniteLineKit : public Object
24948 {
24949 public:
24951  InfiniteLineKit();
24952 
24955  InfiniteLineKit(InfiniteLineKit const & in_kit);
24956 
24960  InfiniteLineKit(InfiniteLineKit && in_that);
24961 
24965  InfiniteLineKit & operator=(InfiniteLineKit && in_that);
24966 
24967  virtual ~InfiniteLineKit();
24968 
24969  HPS::Type ObjectType() const { return HPS::Type::InfiniteLineKit; };
24970 
24973  void Consume(InfiniteLineKit & in_kit);
24974 
24977  void Set(InfiniteLineKit const & in_kit);
24978 
24981  void Show(InfiniteLineKit & out_kit) const;
24982 
24986  InfiniteLineKit & operator=(InfiniteLineKit const & in_kit);
24987 
24990  bool Empty() const;
24991 
24995  bool Equals(InfiniteLineKit const & in_kit) const;
24996 
25000  bool operator==(InfiniteLineKit const & in_kit) const;
25001 
25005  bool operator!=(InfiniteLineKit const & in_kit) const;
25006 
25013  InfiniteLineKit & SetPriority(int in_priority);
25014 
25017  InfiniteLineKit & UnsetPriority();
25018 
25022  bool ShowPriority(int & out_priority) const;
25023 
25024 
25028  InfiniteLineKit & SetFirst(Point const & in_first);
25029 
25033  InfiniteLineKit & SetSecond(Point const & in_second);
25034 
25038  InfiniteLineKit & SetType(InfiniteLine::Type in_type);
25039 
25040 
25043  InfiniteLineKit & UnsetFirst();
25044 
25047  InfiniteLineKit & UnsetSecond();
25048 
25051  InfiniteLineKit & UnsetType();
25052 
25055  InfiniteLineKit & UnsetEverything();
25056 
25057 
25061  bool ShowFirst(Point & out_first) const;
25062 
25066  bool ShowSecond(Point & out_second) const;
25067 
25071  bool ShowType(InfiniteLine::Type & out_type) const;
25072 
25078  InfiniteLineKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
25079 
25084  InfiniteLineKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
25085 
25090  InfiniteLineKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
25091 
25095  InfiniteLineKit & UnsetUserData(intptr_t in_index);
25096 
25101  InfiniteLineKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
25102 
25106  InfiniteLineKit & UnsetUserData(IntPtrTArray const & in_indices);
25107 
25110  InfiniteLineKit & UnsetAllUserData();
25111 
25113  size_t ShowUserDataCount() const;
25114 
25118  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
25119 
25124  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
25125 
25130  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
25131 };
25132 
25133 
25135 class HPS_API InfiniteLineKey : public GeometryKey
25136 {
25137 public:
25139  InfiniteLineKey();
25140 
25144  explicit InfiniteLineKey(Key const & in_that);
25145 
25148  InfiniteLineKey(InfiniteLineKey const & in_that);
25149 
25153  InfiniteLineKey & operator=(InfiniteLineKey const & in_that);
25154 
25158  InfiniteLineKey(InfiniteLineKey && in_that);
25159 
25163  InfiniteLineKey & operator=(InfiniteLineKey && in_that);
25164 
25165  ~InfiniteLineKey();
25166 
25167  HPS::Type ObjectType() const { return HPS::Type::InfiniteLineKey; };
25168 
25171  void Consume(InfiniteLineKit & in_kit);
25172 
25175  void Set(InfiniteLineKit const & in_kit);
25176 
25179  void Show(InfiniteLineKit & out_kit) const;
25180 
25181 
25185  InfiniteLineKey & SetFirst(Point const & in_first);
25186 
25190  InfiniteLineKey & SetSecond(Point const & in_second);
25191 
25195  InfiniteLineKey & SetType(InfiniteLine::Type in_type);
25196 
25197 
25201  bool ShowFirst(Point & out_first) const;
25202 
25206  bool ShowSecond(Point & out_second) const;
25207 
25211  bool ShowType(InfiniteLine::Type & out_type) const;
25212 };
25213 
25214 
25215 
25219 class HPS_API SpotlightKit : public Object
25220 {
25221 public:
25223  SpotlightKit();
25224 
25227  SpotlightKit(SpotlightKit const & in_kit);
25228 
25232  SpotlightKit(SpotlightKit && in_that);
25233 
25237  SpotlightKit & operator=(SpotlightKit && in_that);
25238 
25239  virtual ~SpotlightKit();
25240 
25241  HPS::Type ObjectType() const { return HPS::Type::SpotlightKit; };
25242 
25246  static SpotlightKit GetDefault();
25247 
25250  void Consume(SpotlightKit & in_kit);
25251 
25254  void Set(SpotlightKit const & in_kit);
25255 
25258  void Show(SpotlightKit & out_kit) const;
25259 
25263  SpotlightKit & operator=(SpotlightKit const & in_kit);
25264 
25267  bool Empty() const;
25268 
25272  bool Equals(SpotlightKit const & in_kit) const;
25273 
25277  bool operator==(SpotlightKit const & in_kit) const;
25278 
25282  bool operator!=(SpotlightKit const & in_kit) const;
25283 
25284 
25291  SpotlightKit & SetPriority(int in_priority);
25292 
25298  SpotlightKit & SetPosition(HPS::Point const & in_position);
25299 
25305  SpotlightKit & SetTarget(HPS::Point const & in_target);
25306 
25310  SpotlightKit & SetColor(RGBAColor const & in_rgba_color);
25311 
25315  SpotlightKit & SetColorByIndex(float in_index);
25316 
25323 
25330 
25336  SpotlightKit & SetConcentration(float in_concentration);
25337 
25343  SpotlightKit & SetCameraRelative(bool in_state);
25344 
25345 
25348  SpotlightKit & UnsetPriority();
25349 
25352  SpotlightKit & UnsetPosition();
25353 
25356  SpotlightKit & UnsetTarget();
25357 
25360  SpotlightKit & UnsetColor();
25361 
25364  SpotlightKit & UnsetOuterCone();
25365 
25368  SpotlightKit & UnsetInnerCone();
25369 
25372  SpotlightKit & UnsetConcentration();
25373 
25376  SpotlightKit & UnsetCameraRelative();
25377 
25380  SpotlightKit & UnsetEverything();
25381 
25382 
25386  bool ShowPriority(int & out_priority) const;
25387 
25391  bool ShowPosition(HPS::Point & out_position) const;
25392 
25396  bool ShowTarget(HPS::Point & out_target) const;
25397 
25403  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
25404 
25409  bool ShowOuterCone(float & out_size, HPS::Spotlight::OuterConeUnits & out_units) const;
25410 
25415  bool ShowInnerCone(float & out_size, HPS::Spotlight::InnerConeUnits & out_units) const;
25416 
25420  bool ShowConcentration(float & out_concentration) const;
25421 
25425  bool ShowCameraRelative(bool & out_state) const;
25426 
25432  SpotlightKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
25433 
25438  SpotlightKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
25439 
25444  SpotlightKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
25445 
25449  SpotlightKit & UnsetUserData(intptr_t in_index);
25450 
25455  SpotlightKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
25456 
25460  SpotlightKit & UnsetUserData(IntPtrTArray const & in_indices);
25461 
25464  SpotlightKit & UnsetAllUserData();
25465 
25467  size_t ShowUserDataCount() const;
25468 
25472  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
25473 
25478  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
25479 
25484  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
25485 };
25486 
25487 
25489 class HPS_API SpotlightKey : public GeometryKey
25490 {
25491 public:
25493  SpotlightKey();
25494 
25498  explicit SpotlightKey(Key const & in_that);
25499 
25502  SpotlightKey(SpotlightKey const & in_that);
25503 
25507  SpotlightKey & operator=(SpotlightKey const & in_that);
25508 
25512  SpotlightKey(SpotlightKey && in_that);
25513 
25517  SpotlightKey & operator=(SpotlightKey && in_that);
25518 
25519  ~SpotlightKey();
25520 
25521  HPS::Type ObjectType() const { return HPS::Type::SpotlightKey; };
25522 
25525  void Consume(SpotlightKit & in_kit);
25526 
25529  void Set(SpotlightKit const & in_kit);
25530 
25533  void Show(SpotlightKit & out_kit) const;
25534 
25535 
25541  SpotlightKey & SetPosition(HPS::Point const & in_position);
25542 
25548  SpotlightKey & SetTarget(HPS::Point const & in_target);
25549 
25553  SpotlightKey & SetColor(RGBAColor const & in_rgba_color);
25554 
25558  SpotlightKey & SetColorByIndex(float in_index);
25559 
25566 
25573 
25579  SpotlightKey & SetConcentration(float in_concentration);
25580 
25586  SpotlightKey & SetCameraRelative(bool in_state);
25587 
25588 
25591  SpotlightKey & UnsetColor();
25592 
25593 
25597  bool ShowPosition(HPS::Point & out_position) const;
25598 
25602  bool ShowTarget(HPS::Point & out_target) const;
25603 
25609  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
25610 
25615  bool ShowOuterCone(float & out_size, HPS::Spotlight::OuterConeUnits & out_units) const;
25616 
25621  bool ShowInnerCone(float & out_size, HPS::Spotlight::InnerConeUnits & out_units) const;
25622 
25626  bool ShowConcentration(float & out_concentration) const;
25627 
25631  bool ShowCameraRelative(bool & out_state) const;
25632 };
25633 
25634 
25635 
25637 class HPS_API NURBSCurveKit : public Object
25638 {
25639 public:
25641  NURBSCurveKit();
25642 
25645  NURBSCurveKit(NURBSCurveKit const & in_kit);
25646 
25650  NURBSCurveKit(NURBSCurveKit && in_that);
25651 
25655  NURBSCurveKit & operator=(NURBSCurveKit && in_that);
25656 
25657  virtual ~NURBSCurveKit();
25658 
25659  HPS::Type ObjectType() const { return HPS::Type::NURBSCurveKit; };
25660 
25663  void Consume(NURBSCurveKit & in_kit);
25664 
25667  void Set(NURBSCurveKit const & in_kit);
25668 
25671  void Show(NURBSCurveKit & out_kit) const;
25672 
25676  NURBSCurveKit & operator=(NURBSCurveKit const & in_kit);
25677 
25680  bool Empty() const;
25681 
25685  bool Equals(NURBSCurveKit const & in_kit) const;
25686 
25690  bool operator==(NURBSCurveKit const & in_kit) const;
25691 
25695  bool operator!=(NURBSCurveKit const & in_kit) const;
25696 
25699  size_t GetPointCount() const;
25700 
25707  NURBSCurveKit & SetPriority(int in_priority);
25708 
25711  NURBSCurveKit & UnsetPriority();
25712 
25716  bool ShowPriority(int & out_priority) const;
25717 
25721  NURBSCurveKit & SetDegree(size_t in_degree);
25722 
25726  NURBSCurveKit & SetPoints(PointArray const & in_points);
25727 
25732  NURBSCurveKit & SetPoints(size_t in_count, Point const in_points []);
25733 
25737  NURBSCurveKit & SetWeights(FloatArray const & in_weights);
25738 
25743  NURBSCurveKit & SetWeights(size_t in_count, float const in_weights []);
25744 
25748  NURBSCurveKit & SetKnots(FloatArray const & in_knots);
25749 
25754  NURBSCurveKit & SetKnots(size_t in_count, float const in_knots []);
25755 
25760  NURBSCurveKit & SetParameters(float in_start, float in_end);
25761 
25762 
25765  NURBSCurveKit & UnsetDegree();
25766 
25769  NURBSCurveKit & UnsetPoints();
25770 
25773  NURBSCurveKit & UnsetWeights();
25774 
25777  NURBSCurveKit & UnsetKnots();
25778 
25781  NURBSCurveKit & UnsetParameters();
25782 
25785  NURBSCurveKit & UnsetEverything();
25786 
25787 
25791  bool ShowDegree(size_t & out_degree) const;
25792 
25796  bool ShowPoints(PointArray & out_points) const;
25797 
25803  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
25804 
25809  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
25810 
25816  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
25817 
25821  bool ShowWeights(FloatArray & out_weights) const;
25822 
25826  bool ShowKnots(FloatArray & out_knots) const;
25827 
25832  bool ShowParameters(float & out_start, float & out_end) const;
25833 
25834 
25841  NURBSCurveKit & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
25842 
25848  NURBSCurveKit & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
25849 
25856  NURBSCurveKit & EditPointsByDeletion(size_t in_offset, size_t in_count);
25857 
25864  NURBSCurveKit & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
25865 
25872  NURBSCurveKit & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
25873 
25874 
25882  NURBSCurveKit & EditWeightsByInsertion(size_t in_offset, size_t in_count, float const in_weights[]);
25883 
25890  NURBSCurveKit & EditWeightsByInsertion(size_t in_offset, FloatArray const & in_weights);
25891 
25899  NURBSCurveKit & EditWeightsByDeletion(size_t in_offset, size_t in_count);
25900 
25907  NURBSCurveKit & EditWeightsByReplacement(size_t in_offset, size_t in_count, float const in_weights[]);
25908 
25915  NURBSCurveKit & EditWeightsByReplacement(size_t in_offset, FloatArray const & in_weights);
25916 
25917 
25923  NURBSCurveKit & EditKnotsByInsertion(size_t in_offset, size_t in_count, float const in_knots[]);
25924 
25929  NURBSCurveKit & EditKnotsByInsertion(size_t in_offset, FloatArray const & in_knots);
25930 
25936  NURBSCurveKit & EditKnotsByDeletion(size_t in_offset, size_t in_count);
25937 
25944  NURBSCurveKit & EditKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
25945 
25952  NURBSCurveKit & EditKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
25953 
25959  NURBSCurveKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
25960 
25965  NURBSCurveKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
25966 
25971  NURBSCurveKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
25972 
25976  NURBSCurveKit & UnsetUserData(intptr_t in_index);
25977 
25982  NURBSCurveKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
25983 
25987  NURBSCurveKit & UnsetUserData(IntPtrTArray const & in_indices);
25988 
25991  NURBSCurveKit & UnsetAllUserData();
25992 
25994  size_t ShowUserDataCount() const;
25995 
25999  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
26000 
26005  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
26006 
26011  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
26012 };
26013 
26014 
26016 class HPS_API NURBSCurveKey : public GeometryKey
26017 {
26018 public:
26020  NURBSCurveKey();
26021 
26025  explicit NURBSCurveKey(Key const & in_that);
26026 
26029  NURBSCurveKey(NURBSCurveKey const & in_that);
26030 
26034  NURBSCurveKey & operator=(NURBSCurveKey const & in_that);
26035 
26039  NURBSCurveKey(NURBSCurveKey && in_that);
26040 
26044  NURBSCurveKey & operator=(NURBSCurveKey && in_that);
26045 
26046  ~NURBSCurveKey();
26047 
26048  HPS::Type ObjectType() const {return HPS::Type::NURBSCurveKey;};
26049 
26052  void Consume(NURBSCurveKit & in_kit);
26053 
26056  void Set(NURBSCurveKit const & in_kit);
26057 
26060  void Show(NURBSCurveKit & out_kit) const;
26061 
26064  size_t GetPointCount() const;
26065 
26070  NURBSCurveKey & SetParameters(float in_start, float in_end);
26071 
26075  bool ShowDegree(size_t & out_degree) const;
26076 
26080  bool ShowPoints(PointArray & out_points) const;
26081 
26087  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
26088 
26093  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
26094 
26100  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
26101 
26105  bool ShowWeights(FloatArray & out_weights) const;
26106 
26110  bool ShowKnots(FloatArray & out_knots) const;
26111 
26116  bool ShowParameters(float & out_start, float & out_end) const;
26117 
26118 
26126  NURBSCurveKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
26127 
26134  NURBSCurveKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
26135 
26136 
26145  NURBSCurveKey & EditWeightsByReplacement(size_t in_offset, size_t in_count, float const in_weights[]);
26146 
26154  NURBSCurveKey & EditWeightsByReplacement(size_t in_offset, FloatArray const & in_weights);
26155 
26156 
26164  NURBSCurveKey & EditKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
26165 
26172  NURBSCurveKey & EditKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
26173 };
26174 
26175 
26176 
26178 class HPS_API NURBSSurfaceKit : public Object
26179 {
26180 public:
26182  NURBSSurfaceKit();
26183 
26186  NURBSSurfaceKit(NURBSSurfaceKit const & in_kit);
26187 
26191  NURBSSurfaceKit(NURBSSurfaceKit && in_that);
26192 
26196  NURBSSurfaceKit & operator=(NURBSSurfaceKit && in_that);
26197 
26198  virtual ~NURBSSurfaceKit();
26199 
26200  HPS::Type ObjectType() const { return HPS::Type::NURBSSurfaceKit; };
26201 
26204  void Consume(NURBSSurfaceKit & in_kit);
26205 
26208  void Set(NURBSSurfaceKit const & in_kit);
26209 
26212  void Show(NURBSSurfaceKit & out_kit) const;
26213 
26217  NURBSSurfaceKit & operator=(NURBSSurfaceKit const & in_kit);
26218 
26221  bool Empty() const;
26222 
26226  bool Equals(NURBSSurfaceKit const & in_kit) const;
26227 
26231  bool operator==(NURBSSurfaceKit const & in_kit) const;
26232 
26236  bool operator!=(NURBSSurfaceKit const & in_kit) const;
26237 
26240  size_t GetPointCount() const;
26241 
26248  NURBSSurfaceKit & SetPriority(int in_priority);
26249 
26252  NURBSSurfaceKit & UnsetPriority();
26253 
26257  bool ShowPriority(int & out_priority) const;
26258 
26262  NURBSSurfaceKit & SetUDegree(size_t in_degree);
26263 
26267  NURBSSurfaceKit & SetVDegree(size_t in_degree);
26268 
26272  NURBSSurfaceKit & SetUCount(size_t in_count);
26273 
26277  NURBSSurfaceKit & SetVCount(size_t in_count);
26278 
26282  NURBSSurfaceKit & SetPoints(PointArray const & in_points);
26283 
26288  NURBSSurfaceKit & SetPoints(size_t in_count, Point const in_points []);
26289 
26294  NURBSSurfaceKit & SetWeights(FloatArray const & in_weights);
26295 
26301  NURBSSurfaceKit & SetWeights(size_t in_count, float const in_weights []);
26302 
26307  NURBSSurfaceKit & SetUKnots(FloatArray const & in_knots);
26308 
26314  NURBSSurfaceKit & SetUKnots(size_t in_count, float const in_knots []);
26315 
26320  NURBSSurfaceKit & SetVKnots(FloatArray const & in_knots);
26321 
26327  NURBSSurfaceKit & SetVKnots(size_t in_count, float const in_knots []);
26328 
26332  NURBSSurfaceKit & SetTrims(TrimKitArray const & in_trims);
26333 
26338  NURBSSurfaceKit & SetTrims(size_t in_count, TrimKit const in_trims []);
26339 
26340 
26343  NURBSSurfaceKit & UnsetUDegree();
26344 
26347  NURBSSurfaceKit & UnsetVDegree();
26348 
26351  NURBSSurfaceKit & UnsetUCount();
26352 
26355  NURBSSurfaceKit & UnsetVCount();
26356 
26359  NURBSSurfaceKit & UnsetPoints();
26360 
26363  NURBSSurfaceKit & UnsetWeights();
26364 
26367  NURBSSurfaceKit & UnsetUKnots();
26368 
26371  NURBSSurfaceKit & UnsetVKnots();
26372 
26375  NURBSSurfaceKit & UnsetTrims();
26376 
26379  NURBSSurfaceKit & UnsetEverything();
26380 
26381 
26385  bool ShowUDegree(size_t & out_degree) const;
26386 
26390  bool ShowVDegree(size_t & out_degree) const;
26391 
26395  bool ShowUCount(size_t & out_count) const;
26396 
26400  bool ShowVCount(size_t & out_count) const;
26401 
26405  bool ShowPoints(PointArray & out_points) const;
26406 
26412  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
26413 
26418  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
26419 
26425  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
26426 
26430  bool ShowWeights(FloatArray & out_weights) const;
26431 
26435  bool ShowUKnots(FloatArray & out_knots) const;
26436 
26440  bool ShowVKnots(FloatArray & out_knots) const;
26441 
26445  bool ShowTrims(TrimKitArray & out_trims) const;
26446 
26447 
26454  NURBSSurfaceKit & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
26455 
26461  NURBSSurfaceKit & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
26462 
26469  NURBSSurfaceKit & EditPointsByDeletion(size_t in_offset, size_t in_count);
26470 
26477  NURBSSurfaceKit & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
26478 
26485  NURBSSurfaceKit & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
26486 
26487 
26495  NURBSSurfaceKit & EditWeightsByInsertion(size_t in_offset, size_t in_count, float const in_weights[]);
26496 
26503  NURBSSurfaceKit & EditWeightsByInsertion(size_t in_offset, FloatArray const & in_weights);
26504 
26512  NURBSSurfaceKit & EditWeightsByDeletion(size_t in_offset, size_t in_count);
26513 
26520  NURBSSurfaceKit & EditWeightsByReplacement(size_t in_offset, size_t in_count, float const in_weights[]);
26521 
26528  NURBSSurfaceKit & EditWeightsByReplacement(size_t in_offset, FloatArray const & in_weights);
26529 
26530 
26537  NURBSSurfaceKit & EditUKnotsByInsertion(size_t in_offset, size_t in_count, float const in_knots[]);
26538 
26544  NURBSSurfaceKit & EditUKnotsByInsertion(size_t in_offset, FloatArray const & in_knots);
26545 
26552  NURBSSurfaceKit & EditUKnotsByDeletion(size_t in_offset, size_t in_count);
26553 
26560  NURBSSurfaceKit & EditUKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
26561 
26568  NURBSSurfaceKit & EditUKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
26569 
26570 
26577  NURBSSurfaceKit & EditVKnotsByInsertion(size_t in_offset, size_t in_count, float const in_knots[]);
26578 
26584  NURBSSurfaceKit & EditVKnotsByInsertion(size_t in_offset, FloatArray const & in_knots);
26585 
26592  NURBSSurfaceKit & EditVKnotsByDeletion(size_t in_offset, size_t in_count);
26593 
26600  NURBSSurfaceKit & EditVKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
26601 
26608  NURBSSurfaceKit & EditVKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
26609 
26615  NURBSSurfaceKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
26616 
26621  NURBSSurfaceKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
26622 
26627  NURBSSurfaceKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
26628 
26632  NURBSSurfaceKit & UnsetUserData(intptr_t in_index);
26633 
26638  NURBSSurfaceKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
26639 
26643  NURBSSurfaceKit & UnsetUserData(IntPtrTArray const & in_indices);
26644 
26647  NURBSSurfaceKit & UnsetAllUserData();
26648 
26650  size_t ShowUserDataCount() const;
26651 
26655  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
26656 
26661  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
26662 
26667  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
26668 };
26669 
26670 
26672 class HPS_API NURBSSurfaceKey : public GeometryKey
26673 {
26674 public:
26676  NURBSSurfaceKey();
26677 
26681  explicit NURBSSurfaceKey(Key const & in_that);
26682 
26685  NURBSSurfaceKey(NURBSSurfaceKey const & in_that);
26686 
26690  NURBSSurfaceKey & operator=(NURBSSurfaceKey const & in_that);
26691 
26695  NURBSSurfaceKey(NURBSSurfaceKey && in_that);
26696 
26700  NURBSSurfaceKey & operator=(NURBSSurfaceKey && in_that);
26701 
26702  ~NURBSSurfaceKey();
26703 
26704  HPS::Type ObjectType() const { return HPS::Type::NURBSSurfaceKey; };
26705 
26708  void Consume(NURBSSurfaceKit & in_kit);
26709 
26712  void Set(NURBSSurfaceKit const & in_kit);
26713 
26716  void Show(NURBSSurfaceKit & out_kit) const;
26717 
26720  size_t GetPointCount() const;
26721 
26726  NURBSSurfaceKey & SetTrims(size_t in_count, TrimKit const in_trims []);
26727 
26731  NURBSSurfaceKey & SetTrims(TrimKitArray const & in_trims);
26732 
26733 
26736  NURBSSurfaceKey & UnsetTrims();
26737 
26738 
26742  bool ShowUDegree(size_t & out_degree) const;
26743 
26747  bool ShowVDegree(size_t & out_degree) const;
26748 
26752  bool ShowUCount(size_t & out_count) const;
26753 
26757  bool ShowVCount(size_t & out_count) const;
26758 
26762  bool ShowPoints(PointArray & out_points) const;
26763 
26769  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
26770 
26775  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
26776 
26782  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
26783 
26787  bool ShowWeights(FloatArray & out_weights) const;
26788 
26792  bool ShowUKnots(FloatArray & out_knots) const;
26793 
26797  bool ShowVKnots(FloatArray & out_knots) const;
26798 
26802  bool ShowTrims(TrimKitArray & out_trims) const;
26803 
26804 
26812  NURBSSurfaceKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
26813 
26820  NURBSSurfaceKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
26821 
26822 
26831  NURBSSurfaceKey & EditWeightsByReplacement(size_t in_offset, size_t in_count, float const in_weights[]);
26832 
26840  NURBSSurfaceKey & EditWeightsByReplacement(size_t in_offset, FloatArray const & in_weights);
26841 
26842 
26850  NURBSSurfaceKey & EditUKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
26851 
26858  NURBSSurfaceKey & EditUKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
26859 
26860 
26868  NURBSSurfaceKey & EditVKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
26869 
26876  NURBSSurfaceKey & EditVKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
26877 };
26878 
26879 
26880 
26882 class HPS_API TrimElement : public Object
26883 {
26884 public:
26886  TrimElement();
26887 
26890  TrimElement(TrimElement const & in_that);
26891 
26895  TrimElement(LineKit const & in_line);
26896 
26900  TrimElement(NURBSCurveKit const & in_curve);
26901 
26905  TrimElement(TrimElement && in_that);
26906 
26910  TrimElement & operator=(TrimElement && in_that);
26911 
26912  ~TrimElement();
26913 
26914  HPS::Type ObjectType() const { return HPS::Type::TrimElement; };
26915 
26918  void Set(TrimElement const & in_that);
26919 
26923  TrimElement & operator=(TrimElement const & in_that);
26924 
26928  bool Equals(TrimElement const & in_that) const;
26929 
26933  bool operator==(TrimElement const & in_that) const;
26934 
26938  bool operator!=(TrimElement const & in_that) const;
26939 
26940 
26944  void SetCurve(LineKit const & in_line);
26945 
26949  void SetCurve(NURBSCurveKit const & in_curve);
26950 
26956  bool ShowCurve(Trim::Type & out_type, LineKit & out_line, NURBSCurveKit & out_curve) const;
26957 };
26958 
26959 
26960 
26962 class HPS_API TrimKit : public Object
26963 {
26964 public:
26966  TrimKit();
26967 
26970  TrimKit(TrimKit const & in_kit);
26971 
26975  TrimKit(TrimKit && in_that);
26976 
26980  TrimKit & operator=(TrimKit && in_that);
26981 
26982  virtual ~TrimKit();
26983 
26984  HPS::Type ObjectType() const { return HPS::Type::TrimKit; };
26985 
26988  void Set(TrimKit const & in_kit);
26989 
26992  void Show(TrimKit & out_kit) const;
26993 
26997  TrimKit & operator=(TrimKit const & in_kit);
26998 
27001  bool Empty() const;
27002 
27006  bool Equals(TrimKit const & in_kit) const;
27007 
27011  bool operator==(TrimKit const & in_kit) const;
27012 
27016  bool operator!=(TrimKit const & in_kit) const;
27017 
27018 
27023  TrimKit & SetShape(size_t in_count, TrimElement const in_shape[]);
27024 
27028  TrimKit & SetShape(TrimElementArray const & in_shape);
27029 
27033  TrimKit & SetOperation(Trim::Operation in_operation);
27034 
27035 
27038  TrimKit & UnsetShape();
27039 
27042  TrimKit & UnsetOperation();
27043 
27046  TrimKit & UnsetEverything();
27047 
27048 
27052  bool ShowShape(TrimElementArray & out_shape) const;
27053 
27057  bool ShowOperation(Trim::Operation & out_operation) const;
27058 };
27059 
27060 
27061 
27063 class HPS_API EllipseKit : public Object
27064 {
27065 public:
27067  EllipseKit();
27068 
27071  EllipseKit(EllipseKit const & in_kit);
27072 
27076  EllipseKit(EllipseKit && in_that);
27077 
27081  EllipseKit & operator=(EllipseKit && in_that);
27082 
27083  virtual ~EllipseKit();
27084 
27085  HPS::Type ObjectType() const { return HPS::Type::EllipseKit; };
27086 
27089  void Consume(EllipseKit & in_kit);
27090 
27093  void Set(EllipseKit const & in_kit);
27094 
27097  void Show(EllipseKit & out_kit) const;
27098 
27102  EllipseKit & operator=(EllipseKit const & in_kit);
27103 
27106  bool Empty() const;
27107 
27111  bool Equals(EllipseKit const & in_kit) const;
27112 
27116  bool operator==(EllipseKit const & in_kit) const;
27117 
27121  bool operator!=(EllipseKit const & in_kit) const;
27122 
27129  EllipseKit & SetPriority(int in_priority);
27130 
27133  EllipseKit & UnsetPriority();
27134 
27138  bool ShowPriority(int & out_priority) const;
27139 
27140 
27144  EllipseKit & SetCenter(Point const & in_center);
27145 
27149  EllipseKit & SetMajor(Point const & in_major);
27150 
27154  EllipseKit & SetMinor(Point const & in_minor);
27155 
27156 
27159  EllipseKit & UnsetCenter();
27160 
27163  EllipseKit & UnsetMajor();
27164 
27167  EllipseKit & UnsetMinor();
27168 
27171  EllipseKit & UnsetEverything();
27172 
27173 
27177  bool ShowCenter(Point & out_center) const;
27178 
27182  bool ShowMajor(Point & out_major) const;
27183 
27187  bool ShowMinor(Point & out_minor) const;
27188 
27194  EllipseKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
27195 
27200  EllipseKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
27201 
27206  EllipseKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
27207 
27211  EllipseKit & UnsetUserData(intptr_t in_index);
27212 
27217  EllipseKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
27218 
27222  EllipseKit & UnsetUserData(IntPtrTArray const & in_indices);
27223 
27226  EllipseKit & UnsetAllUserData();
27227 
27229  size_t ShowUserDataCount() const;
27230 
27234  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
27235 
27240  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
27241 
27246  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
27247 };
27248 
27249 
27250 
27252 class HPS_API EllipseKey : public GeometryKey
27253 {
27254 public:
27256  EllipseKey();
27257 
27261  explicit EllipseKey(Key const & in_that);
27262 
27265  EllipseKey(EllipseKey const & in_that);
27266 
27270  EllipseKey & operator=(EllipseKey const & other);
27271 
27275  EllipseKey(EllipseKey && in_that);
27276 
27280  EllipseKey & operator=(EllipseKey && in_that);
27281 
27282  ~EllipseKey();
27283 
27284  HPS::Type ObjectType() const { return HPS::Type::EllipseKey; };
27285 
27288  void Consume(EllipseKit & in_kit);
27289 
27292  void Set(EllipseKit const & in_kit);
27293 
27296  void Show(EllipseKit & out_kit) const;
27297 
27298 
27302  EllipseKey & SetCenter(Point const & in_center);
27303 
27307  EllipseKey & SetMajor(Point const & in_major);
27308 
27312  EllipseKey & SetMinor(Point const & in_minor);
27313 
27314 
27318  bool ShowCenter(Point & out_center) const;
27319 
27323  bool ShowMajor(Point & out_major) const;
27324 
27328  bool ShowMinor(Point & out_minor) const;
27329 };
27330 
27331 
27332 
27334 class HPS_API EllipticalArcKit : public Object
27335 {
27336 public:
27338  EllipticalArcKit();
27339 
27342  EllipticalArcKit(EllipticalArcKit const & in_kit);
27343 
27347  EllipticalArcKit(EllipticalArcKit && in_that);
27348 
27352  EllipticalArcKit & operator=(EllipticalArcKit && in_that);
27353 
27354  virtual ~EllipticalArcKit();
27355 
27356  HPS::Type ObjectType() const { return HPS::Type::EllipticalArcKit; };
27357 
27360  void Consume(EllipticalArcKit & in_kit);
27361 
27364  void Set(EllipticalArcKit const & in_kit);
27365 
27368  void Show(EllipticalArcKit & out_kit) const;
27369 
27373  EllipticalArcKit & operator=(EllipticalArcKit const & in_kit);
27374 
27377  bool Empty() const;
27378 
27382  bool Equals(EllipticalArcKit const & in_kit) const;
27383 
27387  bool operator==(EllipticalArcKit const & in_kit) const;
27388 
27392  bool operator!=(EllipticalArcKit const & in_kit) const;
27393 
27400  EllipticalArcKit & SetPriority(int in_priority);
27401 
27404  EllipticalArcKit & UnsetPriority();
27405 
27409  bool ShowPriority(int & out_priority) const;
27410 
27411 
27415  EllipticalArcKit & SetCenter(Point const & in_center);
27416 
27420  EllipticalArcKit & SetMajor(Point const & in_major);
27421 
27425  EllipticalArcKit & SetMinor(Point const & in_minor);
27426 
27434  EllipticalArcKit & SetStart(float in_start);
27435 
27443  EllipticalArcKit & SetEnd(float in_end);
27444 
27445 
27448  EllipticalArcKit & UnsetCenter();
27449 
27452  EllipticalArcKit & UnsetMajor();
27453 
27456  EllipticalArcKit & UnsetMinor();
27457 
27460  EllipticalArcKit & UnsetStart();
27461 
27464  EllipticalArcKit & UnsetEnd();
27465 
27468  EllipticalArcKit & UnsetEverything();
27469 
27470 
27474  bool ShowCenter(Point & out_center) const;
27475 
27479  bool ShowMajor(Point & out_major) const;
27480 
27484  bool ShowMinor(Point & out_minor) const;
27485 
27489  bool ShowStart(float & out_start) const;
27490 
27494  bool ShowEnd(float & out_end) const;
27495 
27501  EllipticalArcKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
27502 
27507  EllipticalArcKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
27508 
27513  EllipticalArcKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
27514 
27518  EllipticalArcKit & UnsetUserData(intptr_t in_index);
27519 
27524  EllipticalArcKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
27525 
27529  EllipticalArcKit & UnsetUserData(IntPtrTArray const & in_indices);
27530 
27533  EllipticalArcKit & UnsetAllUserData();
27534 
27536  size_t ShowUserDataCount() const;
27537 
27541  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
27542 
27547  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
27548 
27553  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
27554 };
27555 
27556 
27558 class HPS_API EllipticalArcKey : public GeometryKey
27559 {
27560 public:
27562  EllipticalArcKey();
27563 
27567  explicit EllipticalArcKey(Key const & in_that);
27568 
27571  EllipticalArcKey(EllipticalArcKey const & in_that);
27572 
27576  EllipticalArcKey & operator=(EllipticalArcKey const & other);
27577 
27581  EllipticalArcKey(EllipticalArcKey && in_that);
27582 
27586  EllipticalArcKey & operator=(EllipticalArcKey && in_that);
27587 
27588  ~EllipticalArcKey();
27589 
27590  HPS::Type ObjectType() const { return HPS::Type::EllipticalArcKey; };
27591 
27592 
27595  void Consume(EllipticalArcKit & in_kit);
27596 
27599  void Set(EllipticalArcKit const & in_kit);
27600 
27603  void Show(EllipticalArcKit & out_kit) const;
27604 
27605 
27609  EllipticalArcKey & SetCenter(Point const & in_center);
27610 
27614  EllipticalArcKey & SetMajor(Point const & in_major);
27615 
27619  EllipticalArcKey & SetMinor(Point const & in_minor);
27620 
27628  EllipticalArcKey & SetStart(float in_start);
27629 
27637  EllipticalArcKey & SetEnd(float in_end);
27638 
27639 
27643  bool ShowCenter(Point & out_center) const;
27644 
27648  bool ShowMajor(Point & out_major) const;
27649 
27653  bool ShowMinor(Point & out_minor) const;
27654 
27658  bool ShowStart(float & out_start) const;
27659 
27663  bool ShowEnd(float & out_end) const;
27664 };
27665 
27666 
27667 
27669 class HPS_API TextKit : public Object
27670 {
27671 public:
27673  TextKit();
27674 
27677  TextKit(TextKit const & in_kit);
27678 
27682  TextKit(TextKit && in_that);
27683 
27687  TextKit & operator=(TextKit && in_that);
27688 
27689  virtual ~TextKit();
27690 
27691  HPS::Type ObjectType() const { return HPS::Type::TextKit; };
27692 
27695  void Consume(TextKit & in_kit);
27696 
27699  void Set(TextKit const & in_kit);
27700 
27703  void Show(TextKit & out_kit) const;
27704 
27708  TextKit & operator=(TextKit const & in_kit);
27709 
27712  bool Empty() const;
27713 
27717  bool Equals(TextKit const & in_kit) const;
27718 
27722  bool operator==(TextKit const & in_kit) const;
27723 
27727  bool operator!=(TextKit const & in_kit) const;
27728 
27735  TextKit & SetPriority(int in_priority);
27736 
27739  TextKit & UnsetPriority();
27740 
27744  bool ShowPriority(int & out_priority) const;
27745 
27749  TextKit & SetPosition(Point const & in_position);
27750 
27754  TextKit & SetText(char const * in_string);
27755 
27759  TextKit & SetColor(RGBAColor const & in_rgba_color);
27760 
27764  TextKit & SetColorByIndex(float in_index);
27765 
27769  TextKit & SetModellingMatrix(MatrixKit const & in_matrix);
27770 
27777 
27781  TextKit & SetBold(bool in_state);
27782 
27786  TextKit & SetItalic(bool in_state);
27787 
27791  TextKit & SetOverline(bool in_state);
27792 
27796  TextKit & SetStrikethrough(bool in_state);
27797 
27801  TextKit & SetUnderline(bool in_state);
27802 
27807  TextKit & SetSlant(float in_angle);
27808 
27812  TextKit & SetLineSpacing(float in_multiplier);
27813 
27819  TextKit & SetRotation(Text::Rotation in_state, float in_angle = 0.0f);
27820 
27824  TextKit & SetRotation(float in_angle);
27825 
27831  TextKit & SetExtraSpace(bool in_state, float in_size = 0.0f, Text::SizeUnits in_units = Text::SizeUnits::ObjectSpace);
27832 
27837  TextKit & SetExtraSpace(float in_size, Text::SizeUnits in_units);
27838 
27845  TextKit & SetGreeking(bool in_state, float in_size = 0.0f, Text::GreekingUnits in_units = Text::GreekingUnits::ObjectSpace, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
27846 
27852  TextKit & SetGreeking(float in_size, Text::GreekingUnits in_units, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
27853 
27862  TextKit & SetSizeTolerance(bool in_state, float in_size = 50.0f, Text::SizeToleranceUnits in_units = Text::SizeToleranceUnits::Percent);
27863 
27871  TextKit & SetSizeTolerance(float in_size, Text::SizeToleranceUnits in_units);
27872 
27877  TextKit & SetSize(float in_size, Text::SizeUnits in_units);
27878 
27884  TextKit & SetFont(char const * in_name);
27885 
27889  TextKit & SetTransform(Text::Transform in_trans);
27890 
27894  TextKit & SetRenderer(Text::Renderer in_rend);
27895 
27899  TextKit & SetPreference(Text::Preference in_pref);
27900 
27907  TextKit & SetPreference(float in_cutoff, Text::SizeUnits in_units, Text::Preference in_smaller, Text::Preference in_larger);
27908 
27912  TextKit & SetPath(Vector const & in_path);
27913 
27919  TextKit & SetSpacing(float in_multiplier);
27920 
27921 
27924  TextKit & UnsetPosition();
27925 
27928  TextKit & UnsetText();
27929 
27932  TextKit & UnsetColor();
27933 
27936  TextKit & UnsetModellingMatrix();
27937 
27940  TextKit & UnsetAlignment();
27941 
27944  TextKit & UnsetBold();
27945 
27948  TextKit & UnsetItalic();
27949 
27952  TextKit & UnsetOverline();
27953 
27956  TextKit & UnsetStrikethrough();
27957 
27960  TextKit & UnsetUnderline();
27961 
27964  TextKit & UnsetSlant();
27965 
27968  TextKit & UnsetLineSpacing();
27969 
27972  TextKit & UnsetRotation();
27973 
27976  TextKit & UnsetExtraSpace();
27977 
27980  TextKit & UnsetGreeking();
27981 
27984  TextKit & UnsetSizeTolerance();
27985 
27988  TextKit & UnsetSize();
27989 
27992  TextKit & UnsetFont();
27993 
27996  TextKit & UnsetTransform();
27997 
28000  TextKit & UnsetRenderer();
28001 
28004  TextKit & UnsetPreference();
28005 
28008  TextKit & UnsetPath();
28009 
28012  TextKit & UnsetSpacing();
28013 
28016  TextKit & UnsetEverything();
28017 
28018 
28022  bool ShowPosition(Point & out_position) const;
28023 
28027  bool ShowText(UTF8 & out_string) const;
28028 
28034  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
28035 
28039  bool ShowModellingMatrix(MatrixKit & out_matrix) const;
28040 
28046  bool ShowAlignment(Text::Alignment & out_alignment, Text::ReferenceFrame & out_reference_frame, Text::Justification & out_justification) const;
28047 
28051  bool ShowBold(bool & out_state) const;
28052 
28056  bool ShowItalic(bool & out_state) const;
28057 
28061  bool ShowOverline(bool & out_state) const;
28062 
28066  bool ShowStrikethrough(bool & out_state) const;
28067 
28071  bool ShowUnderline(bool & out_state) const;
28072 
28076  bool ShowSlant(float & out_angle) const;
28077 
28081  bool ShowLineSpacing(float & out_multiplier) const;
28082 
28087  bool ShowRotation(Text::Rotation & out_rot, float & out_angle) const;
28088 
28094  bool ShowExtraSpace(bool & out_state, float & out_size, Text::SizeUnits & out_units) const;
28095 
28102  bool ShowGreeking(bool & out_state, float & out_size, Text::GreekingUnits & out_units, Text::GreekingMode & out_mode) const;
28103 
28109  bool ShowSizeTolerance(bool & out_state, float & out_size, Text::SizeToleranceUnits & out_units) const;
28110 
28115  bool ShowSize(float & out_size, Text::SizeUnits & out_units) const;
28116 
28120  bool ShowFont(UTF8 & out_name) const;
28121 
28125  bool ShowTransform(Text::Transform & out_trans) const;
28126 
28130  bool ShowRenderer(Text::Renderer & out_renderer) const;
28131 
28138  bool ShowPreference(float & out_cutoff, Text::SizeUnits & out_units, Text::Preference & out_smaller, Text::Preference & out_larger) const;
28139 
28143  bool ShowPath(Vector & out_path) const;
28144 
28148  bool ShowSpacing(float & out_multiplier) const;
28149 
28150 
28158  TextKit & EditTextByInsertion(size_t in_row, size_t in_column, size_t in_count, char const * in_text);
28159 
28166  TextKit & EditTextByDeletion(size_t in_row, size_t in_column, size_t in_count);
28167 
28174  TextKit & EditTextByReplacement(size_t in_row, size_t in_column, size_t in_count, char const * in_text);
28175 
28184  bool ShowRegion(PointArray & out_region, Text::RegionAlignment & out_region_alignment, bool & out_region_fitting, bool & out_region_adjust_direction, bool & out_region_relative_coordinates, bool & out_region_window_space) const;
28185 
28198  TextKit & SetRegion(PointArray & in_region, Text::RegionAlignment in_region_alignment, bool in_region_fitting, bool in_region_adjust_direction, bool in_region_relative_coordinates, bool in_region_window_space);
28199 
28213  TextKit & SetRegion(size_t in_region_count, Point const in_region [], Text::RegionAlignment in_region_alignment, bool in_region_fitting, bool in_region_adjust_direction, bool in_region_relative_coordinates, bool in_region_window_space);
28214 
28220  TextKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
28221 
28224  TextKit & UnsetRegion();
28225 
28230  TextKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
28231 
28236  TextKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
28237 
28241  TextKit & UnsetUserData(intptr_t in_index);
28242 
28247  TextKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
28248 
28252  TextKit & UnsetUserData(IntPtrTArray const & in_indices);
28253 
28256  TextKit & UnsetAllUserData();
28257 
28259  size_t ShowUserDataCount() const;
28260 
28264  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
28265 
28270  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
28271 
28276  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
28277 };
28278 
28279 
28281 class HPS_API TextKey : public GeometryKey
28282 {
28283 public:
28285  TextKey();
28286 
28290  explicit TextKey(Key const & in_that);
28291 
28294  TextKey(TextKey const & in_that);
28295 
28299  TextKey & operator=(TextKey const & other);
28300 
28304  TextKey(TextKey && in_that);
28305 
28309  TextKey & operator=(TextKey && in_that);
28310 
28311  ~TextKey();
28312 
28313  HPS::Type ObjectType() const {return HPS::Type::TextKey;};
28314 
28317  void Consume(TextKit & in_kit);
28318 
28321  void Set(TextKit const & in_kit);
28322 
28325  void Show(TextKit & out_kit) const;
28326 
28329  TextKey & SetTextAttributes(TextAttributeKit const & in_kit);
28330 
28334  bool ShowTextAttributes(TextAttributeKit & out_kit) const;
28335 
28339  TextKey & SetPosition(Point const & in_position);
28340 
28344  TextKey & SetText(char const * in_string);
28345 
28349  TextKey & SetColor(RGBAColor const & in_rgba_color);
28350 
28354  TextKey & SetColorByIndex(float in_index);
28355 
28359  TextKey & SetModellingMatrix(MatrixKit const & in_matrix);
28360 
28367 
28371  TextKey & SetBold(bool in_state);
28372 
28376  TextKey & SetItalic(bool in_state);
28377 
28381  TextKey & SetOverline(bool in_state);
28382 
28386  TextKey & SetStrikethrough(bool in_state);
28387 
28391  TextKey & SetUnderline(bool in_state);
28392 
28397  TextKey & SetSlant(float in_angle);
28398 
28403  TextKey & SetLineSpacing(float in_multiplier);
28404 
28410  TextKey & SetRotation(Text::Rotation in_state, float in_angle = 0.0f);
28411 
28415  TextKey & SetRotation(float in_angle);
28416 
28422  TextKey & SetExtraSpace(bool in_state, float in_size = 0.0f, Text::SizeUnits in_units = Text::SizeUnits::ObjectSpace);
28423 
28428  TextKey & SetExtraSpace(float in_size, Text::SizeUnits in_units);
28429 
28436  TextKey & SetGreeking(bool in_state, float in_size = 0.0f, Text::GreekingUnits in_units = Text::GreekingUnits::ObjectSpace, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
28437 
28443  TextKey & SetGreeking(float in_size, Text::GreekingUnits in_units, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
28444 
28453  TextKey & SetSizeTolerance(bool in_state, float in_size = 50.0f, Text::SizeToleranceUnits in_units = Text::SizeToleranceUnits::Percent);
28454 
28462  TextKey & SetSizeTolerance(float in_size, Text::SizeToleranceUnits in_units);
28463 
28468  TextKey & SetSize(float in_size, Text::SizeUnits in_units);
28469 
28475  TextKey & SetFont(char const * in_name);
28476 
28480  TextKey & SetTransform(Text::Transform in_transform);
28481 
28485  TextKey & SetRenderer(Text::Renderer in_renderer);
28486 
28490  TextKey & SetPreference(Text::Preference in_preference);
28491 
28499  TextKey & SetPreference(float in_cutoff, Text::SizeUnits in_units, Text::Preference in_smaller, Text::Preference in_larger);
28500 
28505  TextKey & SetPath(Vector const & in_path);
28506 
28512  TextKey & SetSpacing(float in_multiplier);
28513 
28526  TextKey & SetRegion(PointArray & in_region, Text::RegionAlignment in_region_alignment, bool in_region_fitting, bool in_region_adjust_direction, bool in_region_relative_coordinates, bool in_region_window_space);
28527 
28541  TextKey & SetRegion(size_t in_region_count, Point const in_region [], Text::RegionAlignment in_region_alignment, bool in_region_fitting, bool in_region_adjust_direction, bool in_region_relative_coordinates, bool in_region_window_space);
28542 
28543 
28546  TextKey & UnsetColor();
28547 
28550  TextKey & UnsetModellingMatrix();
28551 
28554  TextKey & UnsetAlignment();
28555 
28558  TextKey & UnsetBold();
28559 
28562  TextKey & UnsetItalic();
28563 
28566  TextKey & UnsetOverline();
28567 
28570  TextKey & UnsetStrikethrough();
28571 
28574  TextKey & UnsetUnderline();
28575 
28578  TextKey & UnsetSlant();
28579 
28582  TextKey & UnsetLineSpacing();
28583 
28586  TextKey & UnsetRotation();
28587 
28590  TextKey & UnsetExtraSpace();
28591 
28594  TextKey & UnsetGreeking();
28595 
28598  TextKey & UnsetSizeTolerance();
28599 
28602  TextKey & UnsetSize();
28603 
28606  TextKey & UnsetFont();
28607 
28610  TextKey & UnsetTransform();
28611 
28614  TextKey & UnsetRenderer();
28615 
28618  TextKey & UnsetPreference();
28619 
28622  TextKey & UnsetPath();
28623 
28626  TextKey & UnsetSpacing();
28627 
28630  TextKey & UnsetRegion();
28631 
28634  TextKey & UnsetEverything();
28635 
28636 
28640  bool ShowPosition(Point & out_position) const;
28641 
28645  bool ShowText(UTF8 & out_string) const;
28646 
28652  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
28653 
28657  bool ShowModellingMatrix(MatrixKit & out_matrix) const;
28658 
28664  bool ShowAlignment(Text::Alignment & out_alignment, Text::ReferenceFrame & out_reference_frame, Text::Justification & out_justification) const;
28665 
28669  bool ShowBold(bool & out_state) const;
28670 
28674  bool ShowItalic(bool & out_state) const;
28675 
28679  bool ShowOverline(bool & out_state) const;
28680 
28684  bool ShowStrikethrough(bool & out_state) const;
28685 
28689  bool ShowUnderline(bool & out_state) const;
28690 
28694  bool ShowSlant(float & out_angle) const;
28695 
28699  bool ShowLineSpacing(float & out_multiplier) const;
28700 
28705  bool ShowRotation(Text::Rotation & out_rot, float & out_angle) const;
28706 
28712  bool ShowExtraSpace(bool & out_state, float & out_size, Text::SizeUnits & out_units) const;
28713 
28720  bool ShowGreeking(bool & out_state, float & out_size, Text::GreekingUnits & out_units, Text::GreekingMode & out_mode) const;
28721 
28727  bool ShowSizeTolerance(bool & out_state, float & out_size, Text::SizeToleranceUnits & out_units) const;
28728 
28733  bool ShowSize(float & out_size, Text::SizeUnits & out_units) const;
28734 
28738  bool ShowFont(UTF8 & out_name) const;
28739 
28743  bool ShowTransform(Text::Transform & out_trans) const;
28744 
28748  bool ShowRenderer(Text::Renderer & out_renderer) const;
28749 
28756  bool ShowPreference(float & out_cutoff, Text::SizeUnits & out_units, Text::Preference & out_smaller, Text::Preference & out_larger) const;
28757 
28761  bool ShowPath(Vector & out_path) const;
28762 
28766  bool ShowSpacing(float & out_multiplier) const;
28767 
28776  bool ShowRegion(PointArray & out_region, Text::RegionAlignment & out_region_alignment, bool & out_region_fitting, bool & out_region_adjust_direction, bool & out_region_relative_coordinates, bool & out_region_window_space) const;
28777 
28778 
28786  TextKey & EditTextByInsertion(size_t in_row, size_t in_column, size_t in_count, char const * in_text);
28787 
28794  TextKey & EditTextByDeletion(size_t in_row, size_t in_column, size_t in_count);
28795 
28802  TextKey & EditTextByReplacement(size_t in_row, size_t in_column, size_t in_count, char const * in_text);
28803 };
28804 
28805 
28807 class HPS_API ShellOptimizationOptionsKit : public Object
28808 {
28809 public:
28812 
28816 
28821 
28822  virtual ~ShellOptimizationOptionsKit();
28823 
28824  HPS::Type ObjectType() const { return HPS::Type::ShellOptimizationOptionsKit; };
28825 
28828  void Consume(ShellOptimizationOptionsKit & in_kit);
28829 
28832  void Set(ShellOptimizationOptionsKit const & in_kit);
28833 
28836  void Show(ShellOptimizationOptionsKit & out_kit) const;
28837 
28841  ShellOptimizationOptionsKit & operator=(ShellOptimizationOptionsKit const & in_kit);
28842 
28847 
28850  bool Empty() const;
28851 
28855  bool Equals(ShellOptimizationOptionsKit const & in_kit) const;
28856 
28860  bool operator==(ShellOptimizationOptionsKit const & in_kit) const;
28861 
28865  bool operator!=(ShellOptimizationOptionsKit const & in_kit) const;
28866 
28870  static ShellOptimizationOptionsKit GetDefault();
28871 
28872 
28876  ShellOptimizationOptionsKit & SetNormalTolerance(float in_normal_tolerance);
28877 
28882  ShellOptimizationOptionsKit & SetTolerance(float in_tolerance, Shell::ToleranceUnits in_tolerance_units);
28883 
28888  ShellOptimizationOptionsKit & SetOrphanElimination(bool in_orphan_elimination);
28889 
28894  ShellOptimizationOptionsKit & SetHandednessOptimization(Shell::HandednessOptimization in_handedness_option);
28895 
28896 
28899  ShellOptimizationOptionsKit & UnsetNormalTolerance();
28900 
28903  ShellOptimizationOptionsKit & UnsetTolerance();
28904 
28907  ShellOptimizationOptionsKit & UnsetOrphanElimination();
28908 
28911  ShellOptimizationOptionsKit & UnsetHandednessOptimization();
28912 
28915  ShellOptimizationOptionsKit & UnsetEverything();
28916 
28917 
28921  bool ShowNormalTolerance(float & out_normal_tolerance) const;
28922 
28927  bool ShowTolerance(float & out_tolerance, Shell::ToleranceUnits & out_tolerance_units) const;
28928 
28932  bool ShowOrphanElimination(bool & out_orphan_elimination) const;
28933 
28938  bool ShowHandednessOptimization(Shell::HandednessOptimization & out_handedness_option) const;
28939 };
28940 
28941 
28945 class HPS_API ShellRelationOptionsKit : public Object
28946 {
28947 public:
28950 
28954 
28959 
28963  ShellRelationOptionsKit & operator=(ShellRelationOptionsKit && in_that);
28964 
28965  virtual ~ShellRelationOptionsKit();
28966 
28967  HPS::Type ObjectType() const { return HPS::Type::ShellRelationOptionsKit; };
28968 
28972  static ShellRelationOptionsKit GetDefault();
28973 
28976  void Consume(ShellRelationOptionsKit & in_kit);
28977 
28980  void Set(ShellRelationOptionsKit const & in_kit);
28981 
28984  void Show(ShellRelationOptionsKit & out_kit) const;
28985 
28989  ShellRelationOptionsKit & operator=(ShellRelationOptionsKit const & in_kit);
28990 
28993  bool Empty() const;
28994 
28998  bool Equals(ShellRelationOptionsKit const & in_kit) const;
28999 
29003  bool operator==(ShellRelationOptionsKit const & in_kit) const;
29004 
29008  bool operator!=(ShellRelationOptionsKit const & in_kit) const;
29009 
29010 
29014  ShellRelationOptionsKit & SetTolerance(float in_tolerance);
29015 
29019  ShellRelationOptionsKit & SetTest(Shell::RelationTest in_test);
29020 
29025  ShellRelationOptionsKit & SetTreeContext(TreeContext const & in_tree_context);
29026 
29030  ShellRelationOptionsKit & SetNearestFaceCalculation(bool in_state);
29031 
29032 
29035  ShellRelationOptionsKit & UnsetTolerance();
29036 
29039  ShellRelationOptionsKit & UnsetTest();
29040 
29043  ShellRelationOptionsKit & UnsetTreeContext();
29044 
29047  ShellRelationOptionsKit & UnsetNearestFaceCalculation();
29048 
29051  ShellRelationOptionsKit & UnsetEverything();
29052 
29053 
29057  bool ShowTolerance(float & out_tolerance) const;
29058 
29062  bool ShowTest(Shell::RelationTest & out_test) const;
29063 
29067  bool ShowTreeContext(TreeContext & out_tree_context) const;
29068 
29072  bool ShowNearestFaceCalculation(bool & out_state) const;
29073 };
29074 
29076 class HPS_API ShellRelationResultsKit : public Object
29077 {
29078 public:
29081 
29085 
29090 
29094  ShellRelationResultsKit & operator=(ShellRelationResultsKit && in_that);
29095 
29096  virtual ~ShellRelationResultsKit();
29097 
29098  HPS::Type ObjectType() const { return HPS::Type::ShellRelationResultsKit; };
29099 
29102  void Consume(ShellRelationResultsKit & in_kit);
29103 
29106  void Set(ShellRelationResultsKit const & in_kit);
29107 
29110  void Show(ShellRelationResultsKit & out_kit) const;
29111 
29115  ShellRelationResultsKit & operator=(ShellRelationResultsKit const & in_kit);
29116 
29119  bool Empty() const;
29120 
29124  bool Equals(ShellRelationResultsKit const & in_kit) const;
29125 
29129  bool operator==(ShellRelationResultsKit const & in_kit) const;
29130 
29134  bool operator!=(ShellRelationResultsKit const & in_kit) const;
29135 
29136 
29140  bool ShowRelations(ShellRelationArray & out_results) const;
29141 
29145  bool ShowNearestFaces(SizeTArray & out_faces) const;
29146 
29150  bool ShowDistances(FloatArray & out_distances) const;
29151 };
29152 
29153 
29155 class HPS_API ShellKit : public Object
29156 {
29157 public:
29159  ShellKit();
29160 
29163  ShellKit(ShellKit const & in_kit);
29164 
29168  ShellKit(ShellKit && in_that);
29169 
29173  ShellKit & operator=(ShellKit && in_that);
29174 
29175  virtual ~ShellKit();
29176 
29177  HPS::Type ObjectType() const { return HPS::Type::ShellKit; };
29178 
29181  void Consume(ShellKit & in_kit);
29182 
29185  void Set(ShellKit const & in_kit);
29186 
29189  void Show(ShellKit & out_kit) const;
29190 
29193  size_t GetPointCount() const;
29194 
29197  size_t GetFaceCount() const;
29198 
29202  ShellKit & operator=(ShellKit const & in_kit);
29203 
29206  bool Empty() const;
29207 
29211  bool Equals(ShellKit const & in_kit) const;
29212 
29216  bool operator==(ShellKit const & in_kit) const;
29217 
29221  bool operator!=(ShellKit const & in_kit) const;
29222 
29229  ShellKit & SetPriority(int in_priority);
29230 
29233  ShellKit & UnsetPriority();
29234 
29238  bool ShowPriority(int & out_priority) const;
29239 
29240 
29241 
29245  ShellKit & SetPoints(PointArray const & in_points);
29246 
29251  ShellKit & SetPoints(size_t in_count, Point const in_points []);
29252 
29256  ShellKit & SetFacelist(IntArray const & in_facelist);
29257 
29262  ShellKit & SetFacelist(size_t in_count, int const in_facelist []);
29263 
29267  ShellKit & SetTristrips(IntArray const & in_tristrips);
29268 
29273  ShellKit & SetTristrips(size_t in_count, int const in_tristrips []);
29274 
29277  ShellKit & UnsetPoints();
29278 
29281  ShellKit & UnsetFacelist();
29282 
29285  ShellKit & UnsetTristrips();
29286 
29289  ShellKit & UnsetEverything();
29290 
29294  bool ShowPoints(PointArray & out_points) const;
29295 
29301  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
29302 
29307  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
29308 
29314  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
29315 
29319  bool ShowFacelist(IntArray & out_facelist) const;
29320 
29324  bool ShowTristrips(IntArray & out_tristrips) const;
29325 
29331  ShellKit & SetMaterialMapping(MaterialMappingKit const & in_kit);
29332 
29333 
29340  ShellKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
29341 
29347  ShellKit & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Shell::Component in_apply_to = Shell::Component::Faces);
29348 
29355  ShellKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
29356 
29363  ShellKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
29364 
29371  ShellKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Shell::Component in_apply_to = Shell::Component::Faces);
29372 
29379  ShellKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
29380 
29386  ShellKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
29387 
29388 
29395  ShellKit & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const in_rgba_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
29396 
29402  ShellKit & SetVertexRGBAColorsByRange(size_t in_start, RGBAColorArray const & in_rgba_colors, Shell::Component in_apply_to = Shell::Component::Faces);
29403 
29410  ShellKit & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
29411 
29418  ShellKit & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const in_rgba_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
29419 
29426  ShellKit & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColorArray const & in_rgba_colors, Shell::Component in_apply_to = Shell::Component::Faces);
29427 
29434  ShellKit & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
29435 
29441  ShellKit & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
29442 
29443 
29450  ShellKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Shell::Component in_apply_to = Shell::Component::Faces);
29451 
29457  ShellKit & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Shell::Component in_apply_to = Shell::Component::Faces);
29458 
29465  ShellKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
29466 
29473  ShellKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Shell::Component in_apply_to = Shell::Component::Faces);
29474 
29481  ShellKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Shell::Component in_apply_to = Shell::Component::Faces);
29482 
29489  ShellKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
29490 
29496  ShellKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
29497 
29498 
29504  ShellKit & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
29505 
29510  ShellKit & SetVertexNormalsByRange(size_t in_start, VectorArray const & in_normals);
29511 
29517  ShellKit & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
29518 
29524  ShellKit & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const in_normals[]);
29525 
29530  ShellKit & SetVertexNormalsByList(SizeTArray const & in_vertices, VectorArray const & in_normals);
29531 
29537  ShellKit & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const & in_normal);
29538 
29543  ShellKit & SetVertexNormalsByList(SizeTArray const & in_vertices, Vector const & in_normal);
29544 
29545 
29552  ShellKit & SetVertexParametersByRange(size_t in_start, size_t in_param_count, float const in_params[], size_t in_param_width=2);
29553 
29560  ShellKit & SetVertexParametersByRange(size_t in_start, FloatArray const & in_params, size_t in_param_width=2);
29561 
29570  ShellKit & SetVertexParametersByList(size_t in_vertex_count, size_t const in_vertices[], size_t in_param_count, float const in_params[], size_t in_param_width=2);
29571 
29579  ShellKit & SetVertexParametersByList(SizeTArray const & in_vertices, FloatArray const & in_params, size_t in_param_width=2);
29580 
29581 
29587  ShellKit & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
29588 
29593  ShellKit & SetVertexVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
29594 
29600  ShellKit & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
29601 
29607  ShellKit & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool const in_visibilities[]);
29608 
29613  ShellKit & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray const & in_visibilities);
29614 
29620  ShellKit & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool in_visibility);
29621 
29626  ShellKit & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, bool in_visibility);
29627 
29628 
29631  ShellKit & UnsetMaterialMapping();
29632 
29633 
29636  ShellKit & UnsetVertexColors();
29637 
29642  ShellKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
29643 
29647  ShellKit & UnsetVertexColorsByList(SizeTArray const & in_vertices);
29648 
29649 
29653  ShellKit & UnsetVertexColors(Shell::Component in_apply_to);
29654 
29660  ShellKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Shell::Component in_apply_to);
29661 
29666  ShellKit & UnsetVertexColorsByList(SizeTArray const & in_vertices, Shell::Component in_apply_to);
29667 
29668 
29671  ShellKit & UnsetVertexNormals();
29672 
29677  ShellKit & UnsetVertexNormalsByRange(size_t in_start, size_t in_count);
29678 
29682  ShellKit & UnsetVertexNormalsByList(SizeTArray const & in_vertices);
29683 
29684 
29687  ShellKit & UnsetVertexParameters();
29688 
29693  ShellKit & UnsetVertexParametersByRange(size_t in_start, size_t in_count);
29694 
29698  ShellKit & UnsetVertexParametersByList(SizeTArray const & in_vertices);
29699 
29700 
29703  ShellKit & UnsetVertexVisibilities();
29704 
29709  ShellKit & UnsetVertexVisibilitiesByRange(size_t in_start, size_t in_count);
29710 
29714  ShellKit & UnsetVertexVisibilitiesByList(SizeTArray const & in_vertices);
29715 
29716 
29719  ShellKit & UnsetVertexEverything();
29720 
29721 
29725  bool ShowMaterialMapping(MaterialMappingKit & out_kit) const;
29726 
29727 
29741  bool ShowVertexColorsByRange(size_t in_start, size_t in_count, Shell::Component in_apply_to, MaterialTypeArray & out_types,
29742  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
29743 
29758  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Shell::Component in_apply_to, MaterialTypeArray & out_types,
29759  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
29760 
29761 
29770  bool ShowVertexNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
29771 
29780  bool ShowVertexNormalsByList(SizeTArray const & in_vertices, BoolArray & out_validities, VectorArray & out_normals) const;
29781 
29782 
29792  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params) const;
29793 
29803  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
29804 
29814  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params) const;
29815 
29825  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
29826 
29827 
29836  bool ShowVertexVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
29837 
29846  bool ShowVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities) const;
29847 
29848 
29849 
29855  ShellKit & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[]);
29856 
29861  ShellKit & SetFaceRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors);
29862 
29868  ShellKit & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color);
29869 
29875  ShellKit & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const in_rgb_colors[]);
29876 
29881  ShellKit & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColorArray const & in_rgb_colors);
29882 
29888  ShellKit & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const & in_rgb_color);
29889 
29894  ShellKit & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColor const & in_rgb_color);
29895 
29896 
29902  ShellKit & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[]);
29903 
29908  ShellKit & SetFaceIndexColorsByRange(size_t in_start, FloatArray const & in_indices);
29909 
29915  ShellKit & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float in_index);
29916 
29922  ShellKit & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float const in_indices[]);
29923 
29928  ShellKit & SetFaceIndexColorsByList(SizeTArray const & in_faces, FloatArray const & in_indices);
29929 
29935  ShellKit & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float in_index);
29936 
29941  ShellKit & SetFaceIndexColorsByList(SizeTArray const & in_faces, float in_index);
29942 
29943 
29949  ShellKit & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
29950 
29955  ShellKit & SetFaceNormalsByRange(size_t in_start, VectorArray const & in_normals);
29956 
29962  ShellKit & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
29963 
29969  ShellKit & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const in_normals[]);
29970 
29975  ShellKit & SetFaceNormalsByList(SizeTArray const & in_faces, VectorArray const & in_normals);
29976 
29982  ShellKit & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const & in_normal);
29983 
29988  ShellKit & SetFaceNormalsByList(SizeTArray const & in_faces, Vector const & in_normal);
29989 
29990 
29996  ShellKit & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
29997 
30002  ShellKit & SetFaceVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
30003 
30009  ShellKit & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
30010 
30016  ShellKit & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool const in_visibilities[]);
30017 
30022  ShellKit & SetFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray const & in_visibilities);
30023 
30029  ShellKit & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool in_visibility);
30030 
30035  ShellKit & SetFaceVisibilitiesByList(SizeTArray const & in_faces, bool in_visibility);
30036 
30037 
30040  ShellKit & UnsetFaceColors();
30041 
30046  ShellKit & UnsetFaceColorsByRange(size_t in_start, size_t in_count);
30047 
30051  ShellKit & UnsetFaceColorsByList(SizeTArray const & in_faces);
30052 
30053 
30056  ShellKit & UnsetFaceNormals();
30057 
30062  ShellKit & UnsetFaceNormalsByRange(size_t in_start, size_t in_count);
30063 
30067  ShellKit & UnsetFaceNormalsByList(SizeTArray const & in_vertices);
30068 
30069 
30072  ShellKit & UnsetFaceVisibilities();
30073 
30078  ShellKit & UnsetFaceVisibilitiesByRange(size_t in_start, size_t in_count);
30079 
30083  ShellKit & UnsetFaceVisibilitiesByList(SizeTArray const & in_vertices);
30084 
30085 
30088  ShellKit & UnsetFaceEverything();
30089 
30090 
30100  bool ShowFaceColorsByRange(size_t in_start, size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
30101 
30112  bool ShowFaceColorsByList(SizeTArray const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
30113 
30114 
30123  bool ShowFaceNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
30124 
30133  bool ShowFaceNormalsByList(SizeTArray const & in_faces, BoolArray & out_validities, VectorArray & out_normals) const;
30134 
30135 
30144  bool ShowFaceVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
30145 
30154  bool ShowFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities) const;
30155 
30156 
30163  ShellKit & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
30164 
30170  ShellKit & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
30171 
30177  ShellKit & EditPointsByDeletion(size_t in_offset, size_t in_count);
30178 
30184  ShellKit & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
30185 
30191  ShellKit & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
30192 
30193 
30200  ShellKit & EditFacelistByInsertion(size_t in_offset, size_t in_count, int const in_facelist[]);
30201 
30207  ShellKit & EditFacelistByInsertion(size_t in_offset, IntArray const & in_facelist);
30208 
30214  ShellKit & EditFacelistByDeletion(size_t in_offset, size_t in_count);
30215 
30224  ShellKit & EditFacelistByReplacement(size_t in_offset, size_t in_count, int const in_facelist[]);
30225 
30233  ShellKit & EditFacelistByReplacement(size_t in_offset, IntArray const & in_facelist);
30234 
30237  void Optimize(ShellOptimizationOptionsKit const & in_shell_optimization_kit);
30238 
30243  void ComputeRelation(PointArray const & in_points, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
30244 
30249  void ComputeRelation(ShellKey const & in_points_source, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
30250 
30255  void ComputeRelation(ShellKit const & in_points_source, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
30256 
30262  ShellKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
30263 
30268  ShellKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
30269 
30274  ShellKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
30275 
30279  ShellKit & UnsetUserData(intptr_t in_index);
30280 
30285  ShellKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
30286 
30290  ShellKit & UnsetUserData(IntPtrTArray const & in_indices);
30291 
30294  ShellKit & UnsetAllUserData();
30295 
30297  size_t ShowUserDataCount() const;
30298 
30302  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
30303 
30308  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
30309 
30314  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
30315 };
30316 
30317 
30318 
30320 class HPS_API ShellKey : public GeometryKey
30321 {
30322 public:
30324  ShellKey();
30325 
30330  explicit ShellKey(Key const & in_that);
30331 
30334  ShellKey(ShellKey const & in_that);
30335 
30339  ShellKey & operator=(ShellKey const & other);
30340 
30344  ShellKey(ShellKey && in_that);
30345 
30349  ShellKey & operator=(ShellKey && in_that);
30350 
30351  ~ShellKey();
30352 
30353  HPS::Type ObjectType() const { return HPS::Type::ShellKey; };
30354 
30357  void Consume(ShellKit & in_kit);
30358 
30361  void Set(ShellKit const & in_kit);
30362 
30365  void Show(ShellKit & out_kit) const;
30366 
30369  size_t GetPointCount() const;
30370 
30373  size_t GetFaceCount() const;
30374 
30375 
30379  ShellKey & SetPoints(PointArray const & in_points);
30380 
30385  ShellKey & SetPoints(size_t in_count, Point const in_points []);
30386 
30390  ShellKey & SetFacelist(IntArray const & in_facelist);
30391 
30396  ShellKey & SetFacelist(size_t in_count, int const in_facelist []);
30397 
30401  ShellKey & SetTristrips(IntArray const & in_tristrips);
30402 
30407  ShellKey & SetTristrips(size_t in_count, int const in_tristrips []);
30408 
30413  ShellKey & SetMaterialMapping(MaterialMappingKit const & in_kit);
30414 
30417  ShellKey & UnsetPoints();
30418 
30421  ShellKey & UnsetFacelist();
30422 
30425  ShellKey & UnsetTristrips();
30426 
30429  ShellKey & UnsetMaterialMapping();
30430 
30433  ShellKey & UnsetEverything();
30434 
30438  bool ShowPoints(PointArray & out_points) const;
30439 
30445  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
30446 
30451  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
30452 
30458  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
30459 
30463  bool ShowFacelist(IntArray & out_facelist) const;
30464 
30468  bool ShowTristrips(IntArray & out_tristrips) const;
30469 
30473  bool ShowMaterialMapping(MaterialMappingKit & out_kit) const;
30474 
30475 
30482  ShellKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
30483 
30490  ShellKey & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Shell::Component in_apply_to = Shell::Component::Faces);
30491 
30498  ShellKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
30499 
30506  ShellKey & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
30507 
30514  ShellKey & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Shell::Component in_apply_to = Shell::Component::Faces);
30515 
30522  ShellKey & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
30523 
30529  ShellKey & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
30530 
30531 
30538  ShellKey & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const in_rgba_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
30539 
30546  ShellKey & SetVertexRGBAColorsByRange(size_t in_start, RGBAColorArray const & in_rgba_colors, Shell::Component in_apply_to = Shell::Component::Faces);
30547 
30554  ShellKey & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
30555 
30562  ShellKey & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const in_rgba_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
30563 
30570  ShellKey & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColorArray const & in_rgba_colors, Shell::Component in_apply_to = Shell::Component::Faces);
30571 
30578  ShellKey & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
30579 
30585  ShellKey & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
30586 
30587 
30594  ShellKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Shell::Component in_apply_to = Shell::Component::Faces);
30595 
30602  ShellKey & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Shell::Component in_apply_to = Shell::Component::Faces);
30603 
30610  ShellKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
30611 
30618  ShellKey & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Shell::Component in_apply_to = Shell::Component::Faces);
30619 
30626  ShellKey & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Shell::Component in_apply_to = Shell::Component::Faces);
30627 
30634  ShellKey & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
30635 
30641  ShellKey & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
30642 
30643 
30649  ShellKey & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
30650 
30656  ShellKey & SetVertexNormalsByRange(size_t in_start, VectorArray const & in_normals);
30657 
30663  ShellKey & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
30664 
30670  ShellKey & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const in_normals[]);
30671 
30676  ShellKey & SetVertexNormalsByList(SizeTArray const & in_vertices, VectorArray const & in_normals);
30677 
30683  ShellKey & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const & in_normal);
30684 
30689  ShellKey & SetVertexNormalsByList(SizeTArray const & in_vertices, Vector const & in_normal);
30690 
30691 
30699  ShellKey & SetVertexParametersByRange(size_t in_start, size_t in_param_count, float const in_params[], size_t in_param_width=2);
30700 
30707  ShellKey & SetVertexParametersByRange(size_t in_start, FloatArray const & in_params, size_t in_param_width=2);
30708 
30717  ShellKey & SetVertexParametersByList(size_t in_vertex_count, size_t const in_vertices[], size_t in_param_count, float const in_params[], size_t in_param_width=2);
30718 
30726  ShellKey & SetVertexParametersByList(SizeTArray const & in_vertices, FloatArray const & in_params, size_t in_param_width=2);
30727 
30728 
30734  ShellKey & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
30735 
30741  ShellKey & SetVertexVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
30742 
30748  ShellKey & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
30749 
30755  ShellKey & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool const in_visibilities[]);
30756 
30761  ShellKey & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray const & in_visibilities);
30762 
30768  ShellKey & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool in_visibility);
30769 
30774  ShellKey & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, bool in_visibility);
30775 
30776 
30779  ShellKey & UnsetVertexColors();
30780 
30785  ShellKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
30786 
30790  ShellKey & UnsetVertexColorsByList(SizeTArray const & in_vertices);
30791 
30792 
30796  ShellKey & UnsetVertexColors(Shell::Component in_apply_to);
30797 
30803  ShellKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Shell::Component in_apply_to);
30804 
30809  ShellKey & UnsetVertexColorsByList(SizeTArray const & in_vertices, Shell::Component in_apply_to);
30810 
30811 
30814  ShellKey & UnsetVertexNormals();
30815 
30820  ShellKey & UnsetVertexNormalsByRange(size_t in_start, size_t in_count);
30821 
30825  ShellKey & UnsetVertexNormalsByList(SizeTArray const & in_vertices);
30826 
30827 
30830  ShellKey & UnsetVertexParameters();
30831 
30836  ShellKey & UnsetVertexParametersByRange(size_t in_start, size_t in_count);
30837 
30841  ShellKey & UnsetVertexParametersByList(SizeTArray const & in_vertices);
30842 
30843 
30846  ShellKey & UnsetVertexVisibilities();
30847 
30852  ShellKey & UnsetVertexVisibilitiesByRange(size_t in_start, size_t in_count);
30853 
30857  ShellKey & UnsetVertexVisibilitiesByList(SizeTArray const & in_vertices);
30858 
30859 
30862  ShellKey & UnsetVertexEverything();
30863 
30864 
30878  bool ShowVertexColorsByRange(size_t in_start, size_t in_count, Shell::Component in_apply_to, MaterialTypeArray & out_types,
30879  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
30880 
30895  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Shell::Component in_apply_to, MaterialTypeArray & out_types,
30896  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
30897 
30898 
30907  bool ShowVertexNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
30908 
30917  bool ShowVertexNormalsByList(SizeTArray const & in_vertices, BoolArray & out_validities, VectorArray & out_normals) const;
30918 
30924  bool ShowNetVertexNormalsByRange(size_t in_start, size_t in_count, VectorArray & out_normals) const;
30925 
30935  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params) const;
30936 
30946  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
30947 
30957  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params) const;
30958 
30968  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
30969 
30970 
30979  bool ShowVertexVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
30980 
30989  bool ShowVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities) const;
30990 
30991 
30997  ShellKey & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[]);
30998 
31004  ShellKey & SetFaceRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors);
31005 
31011  ShellKey & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color);
31012 
31018  ShellKey & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const in_rgb_colors[]);
31019 
31024  ShellKey & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColorArray const & in_rgb_colors);
31025 
31031  ShellKey & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const & in_rgb_color);
31032 
31037  ShellKey & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColor const & in_rgb_color);
31038 
31039 
31045  ShellKey & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[]);
31046 
31052  ShellKey & SetFaceIndexColorsByRange(size_t in_start, FloatArray const & in_indices);
31053 
31059  ShellKey & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float in_index);
31060 
31066  ShellKey & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float const in_indices[]);
31067 
31072  ShellKey & SetFaceIndexColorsByList(SizeTArray const & in_faces, FloatArray const & in_indices);
31073 
31079  ShellKey & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float in_index);
31080 
31085  ShellKey & SetFaceIndexColorsByList(SizeTArray const & in_faces, float in_index);
31086 
31087 
31093  ShellKey & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
31094 
31100  ShellKey & SetFaceNormalsByRange(size_t in_start, VectorArray const & in_normals);
31101 
31107  ShellKey & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
31108 
31114  ShellKey & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const in_normals[]);
31115 
31120  ShellKey & SetFaceNormalsByList(SizeTArray const & in_faces, VectorArray const & in_normals);
31121 
31127  ShellKey & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const & in_normal);
31128 
31133  ShellKey & SetFaceNormalsByList(SizeTArray const & in_faces, Vector const & in_normal);
31134 
31135 
31141  ShellKey & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
31142 
31148  ShellKey & SetFaceVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
31149 
31155  ShellKey & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
31156 
31162  ShellKey & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool const in_visibilities[]);
31163 
31168  ShellKey & SetFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray const & in_visibilities);
31169 
31175  ShellKey & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool in_visibility);
31176 
31181  ShellKey & SetFaceVisibilitiesByList(SizeTArray const & in_faces, bool in_visibility);
31182 
31183 
31186  ShellKey & UnsetFaceColors();
31187 
31192  ShellKey & UnsetFaceColorsByRange(size_t in_start, size_t in_count);
31193 
31197  ShellKey & UnsetFaceColorsByList(SizeTArray const & in_vertices);
31198 
31199 
31202  ShellKey & UnsetFaceNormals();
31203 
31208  ShellKey & UnsetFaceNormalsByRange(size_t in_start, size_t in_count);
31209 
31213  ShellKey & UnsetFaceNormalsByList(SizeTArray const & in_vertices);
31214 
31215 
31218  ShellKey & UnsetFaceVisibilities();
31219 
31224  ShellKey & UnsetFaceVisibilitiesByRange(size_t in_start, size_t in_count);
31225 
31229  ShellKey & UnsetFaceVisibilitiesByList(SizeTArray const & in_vertices);
31230 
31231 
31234  ShellKey & UnsetFaceEverything();
31235 
31236 
31246  bool ShowFaceColorsByRange(size_t in_start, size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
31247 
31258  bool ShowFaceColorsByList(SizeTArray const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
31259 
31260 
31269  bool ShowFaceNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
31270 
31279  bool ShowFaceNormalsByList(SizeTArray const & in_faces, BoolArray & out_validities, VectorArray & out_normals) const;
31280 
31281 
31287  bool ShowNetFaceNormalsByRange(size_t in_start, size_t in_count, VectorArray & out_normals) const;
31288 
31295  bool ShowNetFaceNormalsByList(SizeTArray const & in_faces, VectorArray & out_normals) const;
31296 
31297 
31306  bool ShowFaceVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
31307 
31316  bool ShowFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities) const;
31317 
31318 
31325  ShellKey & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
31326 
31332  ShellKey & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
31333 
31339  ShellKey & EditPointsByDeletion(size_t in_offset, size_t in_count);
31340 
31346  ShellKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
31347 
31353  ShellKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
31354 
31355 
31362  ShellKey & EditFacelistByInsertion(size_t in_offset, size_t in_count, int const in_facelist[]);
31363 
31369  ShellKey & EditFacelistByInsertion(size_t in_offset, IntArray const & in_facelist);
31370 
31376  ShellKey & EditFacelistByDeletion(size_t in_offset, size_t in_count);
31377 
31386  ShellKey & EditFacelistByReplacement(size_t in_offset, size_t in_count, int const in_facelist[]);
31387 
31395  ShellKey & EditFacelistByReplacement(size_t in_offset, IntArray const & in_facelist);
31396 
31399  void Optimize(ShellOptimizationOptionsKit const & in_shell_optimization_kit);
31400 
31405  void ComputeRelation(PointArray const & in_points, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
31406 
31411  void ComputeRelation(ShellKey const & in_points_source, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
31412 
31417  void ComputeRelation(ShellKit const & in_points_source, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
31418 };
31419 
31420 
31421 
31423 class HPS_API MeshKit : public Object
31424 {
31425 public:
31427  MeshKit();
31428 
31431  MeshKit(MeshKit const & in_kit);
31432 
31436  MeshKit(MeshKit && in_that);
31437 
31441  MeshKit & operator=(MeshKit && in_that);
31442 
31443  virtual ~MeshKit();
31444 
31445  HPS::Type ObjectType() const { return HPS::Type::MeshKit; };
31446 
31449  void Consume(MeshKit & in_kit);
31450 
31453  void Set(MeshKit const & in_kit);
31454 
31457  void Show(MeshKit & out_kit) const;
31458 
31462  MeshKit & operator=(MeshKit const & in_kit);
31463 
31466  bool Empty() const;
31467 
31471  bool Equals(MeshKit const & in_kit) const;
31472 
31476  bool operator==(MeshKit const & in_kit) const;
31477 
31481  bool operator!=(MeshKit const & in_kit) const;
31482 
31485  size_t GetPointCount() const;
31486 
31493  MeshKit & SetPriority(int in_priority);
31494 
31497  MeshKit & UnsetPriority();
31498 
31502  bool ShowPriority(int & out_priority) const;
31503 
31507  MeshKit & SetPoints(PointArray const & in_points);
31508 
31513  MeshKit & SetPoints(size_t in_count, Point const in_points []);
31514 
31520  MeshKit & SetPoints(size_t in_rows, size_t in_columns, HPS::PointArray const & in_points);
31521 
31528  MeshKit & SetPoints(size_t in_rows, size_t in_columns, size_t in_count, Point const in_points []);
31529 
31533  MeshKit & SetRows(size_t in_rows);
31534 
31538  MeshKit & SetColumns(size_t in_columns);
31539 
31542  MeshKit & UnsetPoints();
31543 
31546  MeshKit & UnsetRows();
31547 
31550  MeshKit & UnsetColumns();
31551 
31554  MeshKit & UnsetEverything();
31555 
31559  bool ShowPoints(PointArray & out_points) const;
31560 
31566  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
31567 
31572  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
31573 
31579  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
31580 
31586  bool ShowPoints(size_t & out_rows, size_t & out_columns, PointArray & out_points) const;
31587 
31591  bool ShowRows(size_t & out_rows) const;
31592 
31596  bool ShowColumns(size_t & out_columns) const;
31597 
31598 
31604  MeshKit & SetMaterialMapping(MaterialMappingKit const & in_kit);
31605 
31612  MeshKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
31613 
31619  MeshKit & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
31620 
31627  MeshKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
31628 
31635  MeshKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
31636 
31643  MeshKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
31644 
31651  MeshKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
31652 
31658  MeshKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
31659 
31660 
31667  MeshKit & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const in_rgba_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
31668 
31674  MeshKit & SetVertexRGBAColorsByRange(size_t in_start, RGBAColorArray const & in_rgba_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
31675 
31682  MeshKit & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
31683 
31690  MeshKit & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const in_rgba_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
31691 
31698  MeshKit & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColorArray const & in_rgba_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
31699 
31706  MeshKit & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
31707 
31713  MeshKit & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
31714 
31715 
31722  MeshKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Mesh::Component in_apply_to = Mesh::Component::Faces);
31723 
31729  MeshKit & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Mesh::Component in_apply_to = Mesh::Component::Faces);
31730 
31737  MeshKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
31738 
31745  MeshKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Mesh::Component in_apply_to = Mesh::Component::Faces);
31746 
31753  MeshKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Mesh::Component in_apply_to = Mesh::Component::Faces);
31754 
31761  MeshKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
31762 
31768  MeshKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
31769 
31770 
31776  MeshKit & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
31777 
31782  MeshKit & SetVertexNormalsByRange(size_t in_start, VectorArray const & in_normals);
31783 
31789  MeshKit & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
31790 
31796  MeshKit & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const in_normals[]);
31797 
31802  MeshKit & SetVertexNormalsByList(SizeTArray const & in_vertices, VectorArray const & in_normals);
31803 
31809  MeshKit & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const & in_normal);
31810 
31815  MeshKit & SetVertexNormalsByList(SizeTArray const & in_vertices, Vector const & in_normal);
31816 
31817 
31824  MeshKit & SetVertexParametersByRange(size_t in_start, size_t in_param_count, float const in_params[], size_t in_param_width=2);
31825 
31832  MeshKit & SetVertexParametersByRange(size_t in_start, FloatArray const & in_params, size_t in_param_width=2);
31833 
31842  MeshKit & SetVertexParametersByList(size_t in_vertex_count, size_t const in_vertices[], size_t in_param_count, float const in_params[], size_t in_param_width=2);
31843 
31851  MeshKit & SetVertexParametersByList(SizeTArray const & in_vertices, FloatArray const & in_params, size_t in_param_width=2);
31852 
31853 
31859  MeshKit & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
31860 
31865  MeshKit & SetVertexVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
31866 
31872  MeshKit & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
31873 
31879  MeshKit & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool const in_visibilities[]);
31880 
31885  MeshKit & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray const & in_visibilities);
31886 
31892  MeshKit & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool in_visibility);
31893 
31898  MeshKit & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, bool in_visibility);
31899 
31900 
31903  MeshKit & UnsetMaterialMapping();
31904 
31907  MeshKit & UnsetVertexColors();
31908 
31913  MeshKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
31914 
31918  MeshKit & UnsetVertexColorsByList(SizeTArray const & in_vertices);
31919 
31920 
31924  MeshKit & UnsetVertexColors(Mesh::Component in_apply_to);
31925 
31931  MeshKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Mesh::Component in_apply_to);
31932 
31937  MeshKit & UnsetVertexColorsByList(SizeTArray const & in_vertices, Mesh::Component in_apply_to);
31938 
31939 
31942  MeshKit & UnsetVertexNormals();
31943 
31948  MeshKit & UnsetVertexNormalsByRange(size_t in_start, size_t in_count);
31949 
31953  MeshKit & UnsetVertexNormalsByList(SizeTArray const & in_vertices);
31954 
31955 
31958  MeshKit & UnsetVertexParameters();
31959 
31964  MeshKit & UnsetVertexParametersByRange(size_t in_start, size_t in_count);
31965 
31969  MeshKit & UnsetVertexParametersByList(SizeTArray const & in_vertices);
31970 
31971 
31974  MeshKit & UnsetVertexVisibilities();
31975 
31980  MeshKit & UnsetVertexVisibilitiesByRange(size_t in_start, size_t in_count);
31981 
31985  MeshKit & UnsetVertexVisibilitiesByList(SizeTArray const & in_vertices);
31986 
31987 
31990  MeshKit & UnsetVertexEverything();
31991 
31992 
31996  bool ShowMaterialMapping(MaterialMappingKit & out_kit) const;
31997 
32011  bool ShowVertexColorsByRange(size_t in_start, size_t in_count, Mesh::Component in_apply_to, MaterialTypeArray & out_types,
32012  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
32013 
32028  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Mesh::Component in_apply_to, MaterialTypeArray & out_types,
32029  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
32030 
32031 
32040  bool ShowVertexNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
32041 
32050  bool ShowVertexNormalsByList(SizeTArray const & in_vertices, BoolArray & out_validities, VectorArray & out_normals) const;
32051 
32052 
32062  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params) const;
32063 
32073  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
32074 
32084  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params) const;
32085 
32095  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
32096 
32097 
32106  bool ShowVertexVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
32107 
32116  bool ShowVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities) const;
32117 
32118 
32124  MeshKit & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[]);
32125 
32130  MeshKit & SetFaceRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors);
32131 
32137  MeshKit & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color);
32138 
32144  MeshKit & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const in_rgb_colors[]);
32145 
32150  MeshKit & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColorArray const & in_rgb_colors);
32151 
32157  MeshKit & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const & in_rgb_color);
32158 
32163  MeshKit & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColor const & in_rgb_color);
32164 
32165 
32171  MeshKit & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[]);
32172 
32177  MeshKit & SetFaceIndexColorsByRange(size_t in_start, FloatArray const & in_indices);
32178 
32184  MeshKit & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float in_index);
32185 
32191  MeshKit & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float const in_indices[]);
32192 
32197  MeshKit & SetFaceIndexColorsByList(SizeTArray const & in_faces, FloatArray const & in_indices);
32198 
32204  MeshKit & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float in_index);
32205 
32210  MeshKit & SetFaceIndexColorsByList(SizeTArray const & in_faces, float in_index);
32211 
32212 
32218  MeshKit & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
32219 
32224  MeshKit & SetFaceNormalsByRange(size_t in_start, VectorArray const & in_normals);
32225 
32231  MeshKit & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
32232 
32238  MeshKit & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const in_normals[]);
32239 
32244  MeshKit & SetFaceNormalsByList(SizeTArray const & in_faces, VectorArray const & in_normals);
32245 
32251  MeshKit & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const & in_normal);
32252 
32257  MeshKit & SetFaceNormalsByList(SizeTArray const & in_faces, Vector const & in_normal);
32258 
32259 
32265  MeshKit & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
32266 
32271  MeshKit & SetFaceVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
32272 
32278  MeshKit & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
32279 
32285  MeshKit & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool const in_visibilities[]);
32286 
32291  MeshKit & SetFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray const & in_visibilities);
32292 
32298  MeshKit & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool in_visibility);
32299 
32304  MeshKit & SetFaceVisibilitiesByList(SizeTArray const & in_faces, bool in_visibility);
32305 
32306 
32309  MeshKit & UnsetFaceColors();
32310 
32315  MeshKit & UnsetFaceColorsByRange(size_t in_start, size_t in_count);
32316 
32320  MeshKit & UnsetFaceColorsByList(SizeTArray const & in_vertices);
32321 
32322 
32325  MeshKit & UnsetFaceNormals();
32326 
32331  MeshKit & UnsetFaceNormalsByRange(size_t in_start, size_t in_count);
32332 
32336  MeshKit & UnsetFaceNormalsByList(SizeTArray const & in_vertices);
32337 
32338 
32341  MeshKit & UnsetFaceVisibilities();
32342 
32347  MeshKit & UnsetFaceVisibilitiesByRange(size_t in_start, size_t in_count);
32348 
32352  MeshKit & UnsetFaceVisibilitiesByList(SizeTArray const & in_vertices);
32353 
32354 
32357  MeshKit & UnsetFaceEverything();
32358 
32359 
32369  bool ShowFaceColorsByRange(size_t in_start, size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
32370 
32381  bool ShowFaceColorsByList(SizeTArray const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
32382 
32383 
32392  bool ShowFaceNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
32393 
32402  bool ShowFaceNormalsByList(SizeTArray const & in_faces, BoolArray & out_validities, VectorArray & out_normals) const;
32403 
32404 
32413  bool ShowFaceVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
32414 
32423  bool ShowFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities) const;
32424 
32430  MeshKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
32431 
32436  MeshKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
32437 
32442  MeshKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
32443 
32447  MeshKit & UnsetUserData(intptr_t in_index);
32448 
32453  MeshKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
32454 
32458  MeshKit & UnsetUserData(IntPtrTArray const & in_indices);
32459 
32462  MeshKit & UnsetAllUserData();
32463 
32465  size_t ShowUserDataCount() const;
32466 
32470  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
32471 
32476  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
32477 
32482  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
32483 
32484 };
32485 
32486 
32487 
32489 class HPS_API MeshKey : public GeometryKey
32490 {
32491 public:
32493  MeshKey();
32494 
32499  explicit MeshKey(Key const & in_that);
32500 
32503  MeshKey(MeshKey const & in_that);
32504 
32508  MeshKey & operator=(MeshKey const & in_that);
32509 
32513  MeshKey(MeshKey && in_that);
32514 
32518  MeshKey & operator=(MeshKey && in_that);
32519 
32520  ~MeshKey();
32521 
32522  HPS::Type ObjectType() const { return HPS::Type::MeshKey; };
32523 
32526  void Consume(MeshKit & in_kit);
32527 
32530  void Set(MeshKit const & in_kit);
32531 
32534  void Show(MeshKit & out_kit) const;
32535 
32538  size_t GetPointCount() const;
32539 
32545  MeshKey & SetPoints(size_t in_rows, size_t in_columns, PointArray const & in_points);
32546 
32553  MeshKey & SetPoints(size_t in_rows, size_t in_columns, size_t in_count, Point const in_points []);
32554 
32558  bool ShowPoints(PointArray & out_points) const;
32559 
32565  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
32566 
32571  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
32572 
32578  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
32579 
32585  bool ShowPoints(size_t & out_rows, size_t & out_columns, PointArray & out_points) const;
32586 
32590  bool ShowRows(size_t & out_rows) const;
32591 
32595  bool ShowColumns(size_t & out_columns) const;
32596 
32597 
32602  MeshKey & SetMaterialMapping(MaterialMappingKit const & in_kit);
32603 
32606  MeshKey & UnsetMaterialMapping();
32607 
32611  bool ShowMaterialMapping(MaterialMappingKit & out_kit) const;
32612 
32613 
32620  MeshKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
32621 
32628  MeshKey & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
32629 
32636  MeshKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
32637 
32644  MeshKey & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
32645 
32652  MeshKey & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
32653 
32660  MeshKey & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
32661 
32667  MeshKey & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
32668 
32669 
32676  MeshKey & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const in_rgba_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
32677 
32684  MeshKey & SetVertexRGBAColorsByRange(size_t in_start, RGBAColorArray const & in_rgba_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
32685 
32692  MeshKey & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
32693 
32700  MeshKey & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const in_rgba_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
32701 
32708  MeshKey & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColorArray const & in_rgba_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
32709 
32716  MeshKey & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
32717 
32723  MeshKey & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
32724 
32725 
32732  MeshKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Mesh::Component in_apply_to = Mesh::Component::Faces);
32733 
32740  MeshKey & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Mesh::Component in_apply_to = Mesh::Component::Faces);
32741 
32748  MeshKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
32749 
32756  MeshKey & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Mesh::Component in_apply_to = Mesh::Component::Faces);
32757 
32764  MeshKey & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Mesh::Component in_apply_to = Mesh::Component::Faces);
32765 
32772  MeshKey & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
32773 
32779  MeshKey & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
32780 
32781 
32787  MeshKey & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
32788 
32794  MeshKey & SetVertexNormalsByRange(size_t in_start, VectorArray const & in_normals);
32795 
32801  MeshKey & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
32802 
32808  MeshKey & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const in_normals[]);
32809 
32814  MeshKey & SetVertexNormalsByList(SizeTArray const & in_vertices, VectorArray const & in_normals);
32815 
32821  MeshKey & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const & in_normal);
32822 
32827  MeshKey & SetVertexNormalsByList(SizeTArray const & in_vertices, Vector const & in_normal);
32828 
32829 
32837  MeshKey & SetVertexParametersByRange(size_t in_start, size_t in_param_count, float const in_params[], size_t in_param_width=2);
32838 
32845  MeshKey & SetVertexParametersByRange(size_t in_start, FloatArray const & in_params, size_t in_param_width=2);
32846 
32855  MeshKey & SetVertexParametersByList(size_t in_vertex_count, size_t const in_vertices[], size_t in_param_count, float const in_params[], size_t in_param_width=2);
32856 
32864  MeshKey & SetVertexParametersByList(SizeTArray const & in_vertices, FloatArray const & in_params, size_t in_param_width=2);
32865 
32866 
32872  MeshKey & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
32873 
32879  MeshKey & SetVertexVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
32880 
32886  MeshKey & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
32887 
32893  MeshKey & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool const in_visibilities[]);
32894 
32899  MeshKey & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray const & in_visibilities);
32900 
32906  MeshKey & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool in_visibility);
32907 
32912  MeshKey & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, bool in_visibility);
32913 
32914 
32917  MeshKey & UnsetVertexColors();
32918 
32923  MeshKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
32924 
32928  MeshKey & UnsetVertexColorsByList(SizeTArray const & in_vertices);
32929 
32930 
32934  MeshKey & UnsetVertexColors(Mesh::Component in_apply_to);
32935 
32941  MeshKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Mesh::Component in_apply_to);
32942 
32947  MeshKey & UnsetVertexColorsByList(SizeTArray const & in_vertices, Mesh::Component in_apply_to);
32948 
32949 
32952  MeshKey & UnsetVertexNormals();
32953 
32958  MeshKey & UnsetVertexNormalsByRange(size_t in_start, size_t in_count);
32959 
32963  MeshKey & UnsetVertexNormalsByList(SizeTArray const & in_vertices);
32964 
32965 
32968  MeshKey & UnsetVertexParameters();
32969 
32974  MeshKey & UnsetVertexParametersByRange(size_t in_start, size_t in_count);
32975 
32979  MeshKey & UnsetVertexParametersByList(SizeTArray const & in_vertices);
32980 
32981 
32984  MeshKey & UnsetVertexVisibilities();
32985 
32990  MeshKey & UnsetVertexVisibilitiesByRange(size_t in_start, size_t in_count);
32991 
32995  MeshKey & UnsetVertexVisibilitiesByList(SizeTArray const & in_vertices);
32996 
32997 
33000  MeshKey & UnsetVertexEverything();
33001 
33004  MeshKey & UnsetEverything();
33005 
33006 
33020  bool ShowVertexColorsByRange(size_t in_start, size_t in_count, Mesh::Component in_apply_to, MaterialTypeArray & out_types,
33021  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
33022 
33037  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Mesh::Component in_apply_to, MaterialTypeArray & out_types,
33038  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
33039 
33040 
33049  bool ShowVertexNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
33050 
33059  bool ShowVertexNormalsByList(SizeTArray const & in_vertices, BoolArray & out_validities, VectorArray & out_normals) const;
33060 
33061 
33071  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params) const;
33072 
33082  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
33083 
33093  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params) const;
33094 
33104  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
33105 
33106 
33115  bool ShowVertexVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
33116 
33125  bool ShowVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities) const;
33126 
33127 
33133  MeshKey & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[]);
33134 
33140  MeshKey & SetFaceRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors);
33141 
33147  MeshKey & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color);
33148 
33154  MeshKey & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const in_rgb_colors[]);
33155 
33160  MeshKey & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColorArray const & in_rgb_colors);
33161 
33167  MeshKey & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const & in_rgb_color);
33168 
33173  MeshKey & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColor const & in_rgb_color);
33174 
33175 
33181  MeshKey & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[]);
33182 
33188  MeshKey & SetFaceIndexColorsByRange(size_t in_start, FloatArray const & in_indices);
33189 
33195  MeshKey & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float in_index);
33196 
33202  MeshKey & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float const in_indices[]);
33203 
33208  MeshKey & SetFaceIndexColorsByList(SizeTArray const & in_faces, FloatArray const & in_indices);
33209 
33215  MeshKey & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float in_index);
33216 
33221  MeshKey & SetFaceIndexColorsByList(SizeTArray const & in_faces, float in_index);
33222 
33223 
33229  MeshKey & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
33230 
33236  MeshKey & SetFaceNormalsByRange(size_t in_start, VectorArray const & in_normals);
33237 
33243  MeshKey & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
33244 
33250  MeshKey & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const in_normals[]);
33251 
33256  MeshKey & SetFaceNormalsByList(SizeTArray const & in_faces, VectorArray const & in_normals);
33257 
33263  MeshKey & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const & in_normal);
33264 
33269  MeshKey & SetFaceNormalsByList(SizeTArray const & in_faces, Vector const & in_normal);
33270 
33271 
33277  MeshKey & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
33278 
33284  MeshKey & SetFaceVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
33285 
33291  MeshKey & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
33292 
33298  MeshKey & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool const in_visibilities[]);
33299 
33304  MeshKey & SetFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray const & in_visibilities);
33305 
33311  MeshKey & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool in_visibility);
33312 
33317  MeshKey & SetFaceVisibilitiesByList(SizeTArray const & in_faces, bool in_visibility);
33318 
33319 
33322  MeshKey & UnsetFaceColors();
33323 
33328  MeshKey & UnsetFaceColorsByRange(size_t in_start, size_t in_count);
33329 
33333  MeshKey & UnsetFaceColorsByList(SizeTArray const & in_faces);
33334 
33335 
33338  MeshKey & UnsetFaceNormals();
33339 
33344  MeshKey & UnsetFaceNormalsByRange(size_t in_start, size_t in_count);
33345 
33349  MeshKey & UnsetFaceNormalsByList(SizeTArray const & in_faces);
33350 
33351 
33354  MeshKey & UnsetFaceVisibilities();
33355 
33360  MeshKey & UnsetFaceVisibilitiesByRange(size_t in_start, size_t in_count);
33361 
33365  MeshKey & UnsetFaceVisibilitiesByList(SizeTArray const & in_faces);
33366 
33367 
33370  MeshKey & UnsetFaceEverything();
33371 
33372 
33382  bool ShowFaceColorsByRange(size_t in_start, size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
33383 
33394  bool ShowFaceColorsByList(SizeTArray const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
33395 
33396 
33405  bool ShowFaceNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
33406 
33415  bool ShowFaceNormalsByList(SizeTArray const & in_faces, BoolArray & out_validities, VectorArray & out_normals) const;
33416 
33417 
33426  bool ShowFaceVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
33427 
33436  bool ShowFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities) const;
33437 
33446  MeshKey & EditMeshByReplacement(size_t in_row_offset, size_t in_column_offset, size_t in_row_count, size_t in_column_count, size_t in_point_count, Point const in_points[]);
33447 
33455  MeshKey & EditMeshByReplacement(size_t in_row_offset, size_t in_column_offset, size_t in_row_count, size_t in_column_count, PointArray const & in_points);
33456 };
33457 
33458 
33459 
33460 
33462 class HPS_API PolygonKit : public Object
33463 {
33464 public:
33466  PolygonKit();
33467 
33470  PolygonKit(PolygonKit const & in_kit);
33471 
33475  PolygonKit(PolygonKit && in_that);
33476 
33480  PolygonKit & operator=(PolygonKit && in_that);
33481 
33482  virtual ~PolygonKit();
33483 
33484  HPS::Type ObjectType() const { return HPS::Type::PolygonKit; };
33485 
33488  void Consume(PolygonKit & in_kit);
33489 
33492  void Set(PolygonKit const & in_kit);
33493 
33496  void Show(PolygonKit & out_kit) const;
33497 
33501  PolygonKit & operator=(PolygonKit const & in_kit);
33502 
33505  bool Empty() const;
33506 
33510  bool Equals(PolygonKit const & in_kit) const;
33511 
33515  bool operator==(PolygonKit const & in_kit) const;
33516 
33520  bool operator!=(PolygonKit const & in_kit) const;
33521 
33524  size_t GetPointCount() const;
33525 
33532  PolygonKit & SetPriority(int in_priority);
33533 
33536  PolygonKit & UnsetPriority();
33537 
33541  bool ShowPriority(int & out_priority) const;
33542 
33543 
33547  PolygonKit & SetPoints(PointArray const & in_points);
33548 
33553  PolygonKit & SetPoints(size_t in_count, Point const in_points []);
33554 
33557  PolygonKit & UnsetPoints();
33558 
33561  PolygonKit & UnsetEverything();
33562 
33566  bool ShowPoints(PointArray & out_points) const;
33567 
33573  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
33574 
33579  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
33580 
33586  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
33587 
33593  PolygonKit & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
33594 
33599  PolygonKit & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
33600 
33605  PolygonKit & EditPointsByDeletion(size_t in_offset, size_t in_count);
33606 
33612  PolygonKit & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
33613 
33618  PolygonKit & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
33619 
33625  PolygonKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
33626 
33631  PolygonKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
33632 
33637  PolygonKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
33638 
33642  PolygonKit & UnsetUserData(intptr_t in_index);
33643 
33648  PolygonKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
33649 
33653  PolygonKit & UnsetUserData(IntPtrTArray const & in_indices);
33654 
33657  PolygonKit & UnsetAllUserData();
33658 
33660  size_t ShowUserDataCount() const;
33661 
33665  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
33666 
33671  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
33672 
33677  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
33678 };
33679 
33680 
33682 class HPS_API PolygonKey : public GeometryKey
33683 {
33684 public:
33686  PolygonKey();
33687 
33692  explicit PolygonKey(Key const & in_that);
33693 
33696  PolygonKey(PolygonKey const & in_that);
33697 
33701  PolygonKey & operator=(PolygonKey const & in_that);
33702 
33706  PolygonKey(PolygonKey && in_that);
33707 
33711  PolygonKey & operator=(PolygonKey && in_that);
33712 
33713  ~PolygonKey();
33714 
33715  HPS::Type ObjectType() const { return HPS::Type::PolygonKey; };
33716 
33717 
33720  void Consume(PolygonKit & in_kit);
33721 
33724  void Set(PolygonKit const & in_kit);
33725 
33728  void Show(PolygonKit & out_kit) const;
33729 
33732  size_t GetPointCount() const;
33733 
33737  PolygonKey & SetPoints(PointArray const & in_points);
33738 
33743  PolygonKey & SetPoints(size_t in_count, Point const in_points []);
33744 
33748  bool ShowPoints(PointArray & out_points) const;
33749 
33755  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
33756 
33761  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
33762 
33768  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
33769 
33775  PolygonKey & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
33776 
33781  PolygonKey & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
33782 
33787  PolygonKey & EditPointsByDeletion(size_t in_offset, size_t in_count);
33788 
33794  PolygonKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
33795 
33800  PolygonKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
33801 };
33802 
33803 
33804 
33805 
33807 class HPS_API GridKit : public Object
33808 {
33809 public:
33811  GridKit();
33812 
33815  GridKit(GridKit const & in_kit);
33816 
33819  GridKit(GridKit && in_that);
33820 
33821  virtual ~GridKit();
33822 
33823  HPS::Type ObjectType() const { return HPS::Type::GridKit; };
33824 
33827  void Consume(GridKit & in_kit);
33828 
33831  void Set(GridKit const & in_kit);
33832 
33835  void Show(GridKit & out_kit) const;
33836 
33840  GridKit & operator=(GridKit const & in_kit);
33841 
33845  GridKit & operator=(GridKit && in_that);
33846 
33849  bool Empty() const;
33850 
33854  bool Equals(GridKit const & in_kit) const;
33855 
33859  bool operator==(GridKit const & in_kit) const;
33860 
33864  bool operator!=(GridKit const & in_kit) const;
33865 
33866 
33873  GridKit & SetPriority(int in_priority);
33874 
33878  GridKit & SetType(Grid::Type in_type);
33879 
33883  GridKit & SetOrigin(Point const & in_origin);
33884 
33891  GridKit & SetFirstPoint(Point const & in_first_point);
33892 
33900  GridKit & SetSecondPoint(Point const & in_second_point);
33901 
33915  GridKit & SetFirstCount(int in_first_count);
33916 
33927  GridKit & SetSecondCount(int in_second_count);
33928 
33929 
33932  GridKit & UnsetPriority();
33933 
33936  GridKit & UnsetType();
33937 
33940  GridKit & UnsetOrigin();
33941 
33944  GridKit & UnsetFirstPoint();
33945 
33948  GridKit & UnsetSecondPoint();
33949 
33952  GridKit & UnsetFirstCount();
33953 
33956  GridKit & UnsetSecondCount();
33957 
33960  GridKit & UnsetEverything();
33961 
33962 
33966  bool ShowPriority(int & out_priority) const;
33967 
33971  bool ShowType(Grid::Type & out_type) const;
33972 
33976  bool ShowOrigin(Point & out_origin) const;
33977 
33981  bool ShowFirstPoint(Point & out_first_point) const;
33982 
33986  bool ShowSecondPoint(Point & out_second_point) const;
33987 
33991  bool ShowFirstCount(int & out_first_count) const;
33992 
33996  bool ShowSecondCount(int & out_second_count) const;
33997 
34003  GridKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
34004 
34009  GridKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
34010 
34015  GridKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
34016 
34020  GridKit & UnsetUserData(intptr_t in_index);
34021 
34026  GridKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
34027 
34031  GridKit & UnsetUserData(IntPtrTArray const & in_indices);
34032 
34035  GridKit & UnsetAllUserData();
34036 
34038  size_t ShowUserDataCount() const;
34039 
34043  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
34044 
34049  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
34050 
34055  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
34056 };
34057 
34058 
34060 class HPS_API GridKey : public GeometryKey
34061 {
34062 public:
34064  GridKey();
34065 
34070  explicit GridKey(Key const & in_that);
34071 
34074  GridKey(GridKey const & in_that);
34075 
34078  GridKey(GridKey && in_that);
34079 
34083  GridKey & operator=(GridKey const & in_that);
34084 
34088  GridKey & operator=(GridKey && in_that);
34089 
34090  ~GridKey();
34091 
34092  HPS::Type ObjectType() const { return HPS::Type::GridKey; };
34093 
34096  void Consume(GridKit & in_kit);
34097 
34100  void Set(GridKit const & in_kit);
34101 
34104  void Show(GridKit & out_kit) const;
34105 
34106 
34110  GridKey & SetType(Grid::Type in_type);
34111 
34115  GridKey & SetOrigin(Point const & in_origin);
34116 
34123  GridKey & SetFirstPoint(Point const & in_first_point);
34124 
34132  GridKey & SetSecondPoint(Point const & in_second_point);
34133 
34147  GridKey & SetFirstCount(int in_first_count);
34148 
34159  GridKey & SetSecondCount(int in_second_count);
34160 
34161 
34162 
34166  bool ShowType(Grid::Type & out_type) const;
34167 
34171  bool ShowOrigin(Point & out_origin) const;
34172 
34176  bool ShowFirstPoint(Point & out_first_point) const;
34177 
34181  bool ShowSecondPoint(Point & out_second_point) const;
34182 
34186  bool ShowFirstCount(int & out_first_count) const;
34187 
34191  bool ShowSecondCount(int & out_second_count) const;
34192 };
34193 
34194 
34195 
34196 
34198 class HPS_API IncludeKey : public Key
34199 {
34200 public:
34202  IncludeKey();
34203 
34208  explicit IncludeKey(Key const & in_that);
34209 
34212  IncludeKey(IncludeKey const & in_that);
34213 
34217  IncludeKey & operator=(IncludeKey const & in_that);
34218 
34222  IncludeKey(IncludeKey && in_that);
34223 
34227  IncludeKey & operator=(IncludeKey && in_that);
34228 
34229  ~IncludeKey();
34230 
34231 
34232  HPS::Type ObjectType() const { return HPS::Type::IncludeKey; };
34233 
34236  SegmentKey GetTarget() const;
34237 
34238 
34243  IncludeKey & SetPriority(int in_priority);
34244 
34252  IncludeKey & SetCondition(Condition const & in_condition);
34253 
34254 
34257  IncludeKey & UnsetPriority();
34258 
34261  IncludeKey & UnsetCondition();
34262 
34263 
34267  bool ShowPriority(int & out_priority) const;
34268 
34272  bool ShowCondition(Condition & out_condition) const;
34273 
34279  IncludeKey & SetFilter(AttributeLock::Type in_type);
34280 
34287  IncludeKey & SetFilter(size_t in_count, AttributeLock::Type const in_types[]);
34288 
34294  IncludeKey & SetFilter(AttributeLockTypeArray const & in_types);
34295 
34301  IncludeKey & UnsetFilter(AttributeLock::Type in_type);
34302 
34309  IncludeKey & UnsetFilter(size_t in_count, AttributeLock::Type const in_types[]);
34310 
34316  IncludeKey & UnsetFilter(AttributeLockTypeArray const & in_types);
34317 
34323  bool ShowFilter(AttributeLockTypeArray & out_types) const;
34324 
34330  bool ShowFilter(HPS::AttributeLock::Type in_type) const;
34331 };
34332 
34333 
34334 
34336 class HPS_API StyleKey : public Key
34337 {
34338 public:
34340  StyleKey();
34341 
34346  explicit StyleKey(Key const & in_that);
34347 
34350  StyleKey(StyleKey const & in_that);
34351 
34355  StyleKey & operator=(StyleKey const & other);
34356 
34360  StyleKey(StyleKey && in_that);
34361 
34365  StyleKey & operator=(StyleKey && in_that);
34366 
34367  ~StyleKey();
34368 
34369  HPS::Type ObjectType() const { return HPS::Type::StyleKey; };
34370 
34371 
34377  bool ShowSource(Style::Type & out_type, SegmentKey & out_segment, UTF8 & out_name) const;
34378 
34379 
34387  StyleKey & SetCondition(Condition const & in_condition);
34388 
34389 
34392  StyleKey & UnsetCondition();
34393 
34394 
34398  bool ShowCondition(Condition & out_condition) const;
34399 
34400 
34406  StyleKey & SetFilter(AttributeLock::Type in_type);
34407 
34414  StyleKey & SetFilter(size_t in_count, AttributeLock::Type const in_types[]);
34415 
34421  StyleKey & SetFilter(AttributeLockTypeArray const & in_types);
34422 
34428  StyleKey & UnsetFilter(AttributeLock::Type in_type);
34429 
34436  StyleKey & UnsetFilter(size_t in_count, AttributeLock::Type const in_types[]);
34437 
34443  StyleKey & UnsetFilter(AttributeLockTypeArray const & in_types);
34444 
34450  bool ShowFilter(AttributeLockTypeArray & out_types) const;
34451 
34457  bool ShowFilter(HPS::AttributeLock::Type in_type) const;
34458 };
34459 
34460 
34461 
34463 class HPS_API ReferenceKey : public GeometryKey
34464 {
34465 public:
34467  ReferenceKey();
34468 
34473  explicit ReferenceKey(Key const & in_that);
34474 
34477  ReferenceKey(ReferenceKey const & in_that);
34478 
34482  ReferenceKey & operator=(ReferenceKey const & in_that);
34483 
34487  ReferenceKey(ReferenceKey && in_that);
34488 
34492  ReferenceKey & operator=(ReferenceKey && in_that);
34493 
34494  ~ReferenceKey();
34495 
34496  HPS::Type ObjectType() const { return HPS::Type::ReferenceKey; };
34497 
34501  Key GetTarget() const;
34502 
34506  size_t ShowTargets(bool masked=true) const;
34507 
34512  size_t ShowTargets(KeyArray & out_keys, bool masked=true) const;
34513 
34517  size_t ShowGeometryMask() const;
34518 
34523  size_t ShowGeometryMask(SearchTypeArray & out_geometry_types) const;
34524 
34528  ReferenceKey & SetGeometryMask(SearchTypeArray const & in_geometry_types);
34529 
34532  ReferenceKey & UnsetGeometryMask();
34533 
34536  void SetModellingMatrix(MatrixKit const & in_kit);
34537 
34546  ReferenceKey & SetCondition(Condition const & in_condition);
34547 
34548 
34550  void UnsetModellingMatrix();
34551 
34554  ReferenceKey & UnsetCondition();
34555 
34556 
34560  bool ShowModellingMatrix(MatrixKit & out_kit) const;
34561 
34565  bool ShowCondition(Condition & out_condition) const;
34566 
34567 
34570  ModellingMatrixControl GetModellingMatrixControl();
34571 
34574  ModellingMatrixControl const GetModellingMatrixControl() const;
34575 };
34576 
34577 
34578 
34582 class HPS_API StandAloneWindowOptionsKit : public Object
34583 {
34584 public:
34587 
34591 
34596 
34601 
34602  virtual ~StandAloneWindowOptionsKit();
34603 
34604  HPS::Type ObjectType() const { return HPS::Type::StandAloneWindowOptionsKit; };
34605 
34609  static StandAloneWindowOptionsKit GetDefault();
34610 
34613  void Set(StandAloneWindowOptionsKit const & in_kit);
34614 
34617  void Show(StandAloneWindowOptionsKit & out_kit) const;
34618 
34622  StandAloneWindowOptionsKit & operator=(StandAloneWindowOptionsKit const & in_kit);
34623 
34626  bool Empty() const;
34627 
34631  bool Equals(StandAloneWindowOptionsKit const & in_kit) const;
34632 
34636  bool operator==(StandAloneWindowOptionsKit const & in_kit) const;
34637 
34641  bool operator!=(StandAloneWindowOptionsKit const & in_kit) const;
34642 
34646  StandAloneWindowOptionsKit & SetDriver(Window::Driver in_driver);
34647 
34652  StandAloneWindowOptionsKit & SetAntiAliasCapable(bool in_state, unsigned int in_samples = 4);
34653 
34657  StandAloneWindowOptionsKit & SetTitle(char const * in_window_name);
34658 
34663  StandAloneWindowOptionsKit & SetSubscreen(Rectangle const & in_subscreen);
34664 
34668  StandAloneWindowOptionsKit & SetMobility(Window::Mobility in_mobility);
34669 
34673  StandAloneWindowOptionsKit & SetFullScreen(bool in_state);
34674 
34677  StandAloneWindowOptionsKit & UnsetDriver();
34678 
34681  StandAloneWindowOptionsKit & UnsetAntiAliasCapable();
34682 
34685  StandAloneWindowOptionsKit & UnsetTitle();
34686 
34689  StandAloneWindowOptionsKit & UnsetSubscreen();
34690 
34693  StandAloneWindowOptionsKit & UnsetMobility();
34694 
34697  StandAloneWindowOptionsKit & UnsetFullScreen();
34698 
34701  StandAloneWindowOptionsKit & UnsetEverything();
34702 
34706  bool ShowDriver(Window::Driver & out_driver) const;
34707 
34712  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
34713 
34717  bool ShowTitle(UTF8 & out_window_name) const;
34718 
34722  bool ShowSubscreen(Rectangle & out_subscreen) const;
34723 
34727  bool ShowMobility(Window::Mobility & out_mobility) const;
34728 
34732  bool ShowFullScreen(bool & out_state) const;
34733 };
34734 
34735 
34736 
34743 {
34744 public:
34748 
34752 
34757 
34762 
34765 
34766  HPS::Type ObjectType() const { return HPS::Type::StandAloneWindowOptionsControl; };
34767 
34772 
34777  StandAloneWindowOptionsControl & SetSubscreen(Rectangle const & in_subscreen);
34778 
34782  StandAloneWindowOptionsControl & SetMobility(Window::Mobility in_mobility);
34783 
34787  StandAloneWindowOptionsControl & SetFullScreen(bool in_state);
34788 
34792  bool ShowDriver(Window::Driver & out_driver) const;
34793 
34798  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
34799 
34803  bool ShowTitle(UTF8 & out_window_name) const;
34804 
34808  bool ShowSubscreen(Rectangle & out_subscreen) const;
34809 
34813  bool ShowMobility(Window::Mobility & out_mobility) const;
34814 
34818  bool ShowFullScreen(bool & out_state) const;
34819 
34823  bool ShowWindowHandle(WindowHandle & out_window_handle) const;
34824 private:
34827 };
34828 
34829 
34830 
34834 class HPS_API OffScreenWindowOptionsKit : public Object
34835 {
34836 public:
34839 
34843 
34848 
34852  OffScreenWindowOptionsKit & operator=(OffScreenWindowOptionsKit && in_that);
34853 
34854  virtual ~OffScreenWindowOptionsKit();
34855 
34856  HPS::Type ObjectType() const { return HPS::Type::OffScreenWindowOptionsKit; };
34857 
34861  static OffScreenWindowOptionsKit GetDefault();
34862 
34865  void Set(OffScreenWindowOptionsKit const & in_kit);
34866 
34869  void Show(OffScreenWindowOptionsKit & out_kit) const;
34870 
34874  OffScreenWindowOptionsKit & operator=(OffScreenWindowOptionsKit const & in_kit);
34875 
34878  bool Empty() const;
34879 
34883  bool Equals(OffScreenWindowOptionsKit const & in_kit) const;
34884 
34888  bool operator==(OffScreenWindowOptionsKit const & in_kit) const;
34889 
34893  bool operator!=(OffScreenWindowOptionsKit const & in_kit) const;
34894 
34898  OffScreenWindowOptionsKit & SetDriver(Window::Driver in_driver);
34899 
34904  OffScreenWindowOptionsKit & SetAntiAliasCapable(bool in_state, unsigned int in_samples = 4);
34905 
34910  OffScreenWindowOptionsKit & SetHardwareResident(bool in_state);
34911 
34916  OffScreenWindowOptionsKit & SetNativeFormat(Window::ImageFormat in_format, float in_quality = 1.0f);
34917 
34922  OffScreenWindowOptionsKit & SetOpacity(bool in_state, float in_opacity = 1.0f);
34923 
34927  OffScreenWindowOptionsKit & SetOpacity(float in_opacity);
34928 
34931  OffScreenWindowOptionsKit & UnsetDriver();
34932 
34935  OffScreenWindowOptionsKit & UnsetAntiAliasCapable();
34936 
34939  OffScreenWindowOptionsKit & UnsetHardwareResident();
34940 
34943  OffScreenWindowOptionsKit & UnsetNativeFormat();
34944 
34947  OffScreenWindowOptionsKit & UnsetOpacity();
34948 
34951  OffScreenWindowOptionsKit & UnsetEverything();
34952 
34956  bool ShowDriver(Window::Driver & out_driver) const;
34957 
34962  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
34963 
34967  bool ShowHardwareResident(bool & out_state) const;
34968 
34973  bool ShowNativeFormat(Window::ImageFormat & out_format, float & out_quality) const;
34974 
34979  bool ShowOpacity(bool & out_state, float & out_opacity) const;
34980 };
34981 
34985 class HPS_API ApplicationWindowOptionsKit : public Object
34986 {
34987 public:
34990 
34994 
34999 
35004 
35005  virtual ~ApplicationWindowOptionsKit();
35006 
35007  HPS::Type ObjectType() const { return HPS::Type::ApplicationWindowOptionsKit; };
35008 
35012  static ApplicationWindowOptionsKit GetDefault();
35013 
35016  void Set(ApplicationWindowOptionsKit const & in_kit);
35017 
35020  void Show(ApplicationWindowOptionsKit & out_kit) const;
35021 
35025  ApplicationWindowOptionsKit & operator=(ApplicationWindowOptionsKit const & in_kit);
35026 
35029  bool Empty() const;
35030 
35034  bool Equals(ApplicationWindowOptionsKit const & in_kit) const;
35035 
35039  bool operator==(ApplicationWindowOptionsKit const & in_kit) const;
35040 
35044  bool operator!=(ApplicationWindowOptionsKit const & in_kit) const;
35045 
35049  ApplicationWindowOptionsKit & SetDriver(Window::Driver in_driver);
35050 
35055  ApplicationWindowOptionsKit & SetAntiAliasCapable(bool in_state, unsigned int in_samples = 4);
35056 
35060  ApplicationWindowOptionsKit & SetPlatformData(PlatformData in_platform_data);
35061 
35065  ApplicationWindowOptionsKit & SetFramebufferRetention(bool in_retain);
35066 
35069  ApplicationWindowOptionsKit & UnsetDriver();
35070 
35073  ApplicationWindowOptionsKit & UnsetAntiAliasCapable();
35074 
35077  ApplicationWindowOptionsKit & UnsetPlatformData();
35078 
35081  ApplicationWindowOptionsKit & UnsetFramebufferRetention();
35082 
35085  ApplicationWindowOptionsKit & UnsetEverything();
35086 
35090  bool ShowDriver(Window::Driver & out_driver) const;
35091 
35096  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
35097 
35101  bool ShowPlatformData(PlatformData & out_platform_data) const;
35102 
35106  bool ShowFramebufferRetention(bool & out_retain) const;
35107 
35108 };
35109 
35110 
35111 
35114 {
35115 public:
35119 
35123 
35128 
35133 
35136 
35137  HPS::Type ObjectType() const { return HPS::Type::ApplicationWindowOptionsControl; };
35138 
35143 
35148  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
35149 
35153  bool ShowDriver(Window::Driver & out_driver) const;
35154 
35158  bool ShowWindowHandle(WindowHandle & out_window_handle) const;
35159 
35163  bool ShowPlatformData(PlatformData & out_platform_data) const;
35164 
35168  bool ShowFramebufferRetention(bool & out_retain) const;
35169 
35173  ApplicationWindowOptionsControl & SetWindowHandle(WindowHandle in_window_handle);
35174 
35178  ApplicationWindowOptionsControl & SetPlatformData(PlatformData in_platform_data);
35179 
35180 private:
35183 };
35184 
35185 
35186 
35191 class HPS_API StandAloneWindowKey : public WindowKey
35192 {
35193 public:
35196 
35201  StandAloneWindowKey(Key const & in_key);
35202 
35205  StandAloneWindowKey(StandAloneWindowKey const & in_that);
35206 
35211 
35215  StandAloneWindowKey & operator=(StandAloneWindowKey && in_that);
35216 
35218 
35219  HPS::Type ObjectType() const { return HPS::Type::StandAloneWindowKey; };
35220 
35223  StandAloneWindowOptionsControl const GetWindowOptionsControl() const;
35224 
35227  StandAloneWindowOptionsControl GetWindowOptionsControl();
35228 
35232  bool ShowWindowOptions(StandAloneWindowOptionsKit & out_kit) const;
35233 
35236  Window::UpdateStatus Pause();
35237 };
35238 
35239 
35240 
35242 class HPS_API ApplicationWindowKey : public WindowKey
35243 {
35244 public:
35247 
35252  ApplicationWindowKey(Key const & in_key);
35253 
35256  ApplicationWindowKey(ApplicationWindowKey const & in_that);
35257 
35262 
35266  ApplicationWindowKey & operator=(ApplicationWindowKey && in_that);
35267 
35269 
35270  HPS::Type ObjectType() const { return HPS::Type::ApplicationWindowKey; };
35271 
35274  ApplicationWindowOptionsControl const GetWindowOptionsControl() const;
35275 
35278  ApplicationWindowOptionsControl GetWindowOptionsControl();
35279 
35283  bool ShowWindowOptions(ApplicationWindowOptionsKit & out_kit) const;
35284 };
35285 
35289 
35290 
35291 
35293 class HPS_API GlyphElement : public Object
35294 {
35295 public:
35297  GlyphElement();
35298 
35301  GlyphElement(GlyphElement const & in_that);
35302 
35306  GlyphElement(GlyphElement && in_that);
35307 
35311  GlyphElement & operator=(GlyphElement && in_that);
35312 
35313  virtual ~GlyphElement();
35314 
35315  HPS::Type ObjectType() const { return HPS::Type::GlyphElement; };
35316 
35319  void Set(GlyphElement const & in_that);
35320 
35324  GlyphElement & operator=(GlyphElement const & in_that);
35325 
35329  bool Equals(GlyphElement const & in_that) const;
35330 
35334  bool operator==(GlyphElement const & in_that) const;
35335 
35339  bool operator!=(GlyphElement const & in_that) const;
35340 
35343  void SetFill(Glyph::Fill in_fill);
35344 
35347  void SetIndexedColor(byte in_index);
35348 
35350  void SetNormalColor();
35351 
35354  void SetExplicitColor(RGBAColor const & in_color);
35355 
35359  bool ShowFill(Glyph::Fill & out_fill) const;
35360 
35366  bool ShowColor(Glyph::ColorSource & out_source, byte & out_index, RGBAColor & out_color) const;
35367 };
35368 
35369 
35371 class HPS_API LineGlyphElement : public GlyphElement
35372 {
35373 public:
35375  LineGlyphElement();
35376 
35381  LineGlyphElement(GlyphElement const & in_that);
35382 
35385  LineGlyphElement(LineGlyphElement const & in_that);
35386 
35389  explicit LineGlyphElement(GlyphPointArray const & in_points);
35390 
35394  LineGlyphElement(size_t in_count, GlyphPoint const in_points[]);
35395 
35399  LineGlyphElement(LineGlyphElement && in_that);
35400 
35404  LineGlyphElement & operator=(LineGlyphElement && in_that);
35405 
35406  ~LineGlyphElement();
35407 
35408  HPS::Type ObjectType() const { return HPS::Type::LineGlyphElement; };
35409 
35412  void SetPoints(GlyphPointArray const & in_points);
35413 
35417  void SetPoints(size_t in_count, GlyphPoint const in_points[]);
35418 
35422  bool ShowPoints(GlyphPointArray & out_points) const;
35423 };
35424 
35426 class HPS_API DotGlyphElement : public GlyphElement
35427 {
35428 public:
35430  DotGlyphElement();
35431 
35436  DotGlyphElement(GlyphElement const & in_that);
35437 
35440  DotGlyphElement(DotGlyphElement const & in_that);
35441 
35444  explicit DotGlyphElement(GlyphPoint const & in_point);
35445 
35449  DotGlyphElement(DotGlyphElement && in_that);
35450 
35454  DotGlyphElement & operator=(DotGlyphElement && in_that);
35455 
35456  ~DotGlyphElement();
35457 
35458  HPS::Type ObjectType() const { return HPS::Type::DotGlyphElement; };
35459 
35462  void SetPoint(GlyphPoint const & in_point);
35463 
35467  bool ShowPoint(GlyphPoint & out_point) const;
35468 };
35469 
35470 
35472 class HPS_API EllipseGlyphElement : public GlyphElement
35473 {
35474 public:
35477 
35482  EllipseGlyphElement(GlyphElement const & in_that);
35483 
35486  EllipseGlyphElement(EllipseGlyphElement const & in_that);
35487 
35491  EllipseGlyphElement(GlyphPoint const & in_lower_left, GlyphPoint const & in_upper_right);
35492 
35497 
35501  EllipseGlyphElement & operator=(EllipseGlyphElement && in_that);
35502 
35504 
35505  HPS::Type ObjectType() const { return HPS::Type::EllipseGlyphElement; };
35506 
35509  void SetLowerLeft(GlyphPoint const & in_point);
35510 
35513  void SetUpperRight(GlyphPoint const & in_point);
35514 
35518  void SetPoints(GlyphPoint const & in_lower_left, GlyphPoint const & in_upper_right);
35519 
35523  bool ShowLowerLeft(GlyphPoint & out_point) const;
35524 
35528  bool ShowUpperRight(GlyphPoint & out_point) const;
35529 };
35530 
35532 class HPS_API SphereGlyphElement : public GlyphElement
35533 {
35534 public:
35537 
35542  SphereGlyphElement(GlyphElement const & in_that);
35543 
35546  SphereGlyphElement(SphereGlyphElement const & in_that);
35547 
35552 
35556  SphereGlyphElement & operator=(SphereGlyphElement && in_that);
35557 
35558  ~SphereGlyphElement();
35559 
35560  HPS::Type ObjectType() const { return HPS::Type::SphereGlyphElement; };
35561 };
35562 
35563 
35566 {
35567 public:
35570 
35575  CircularArcGlyphElement(GlyphElement const & in_that);
35576 
35580 
35585  CircularArcGlyphElement(GlyphPoint const & in_start, GlyphPoint const & in_intermediate, GlyphPoint const & in_end);
35586 
35591 
35595  CircularArcGlyphElement & operator=(CircularArcGlyphElement && in_that);
35596 
35598 
35599  HPS::Type ObjectType() const { return HPS::Type::CircularArcGlyphElement; };
35600 
35603  void SetStartPoint(GlyphPoint const & in_point);
35604 
35607  void SetIntermediatePoint(GlyphPoint const & in_point);
35608 
35611  void SetEndPoint(GlyphPoint const & in_point);
35612 
35617  void SetPoints(GlyphPoint const & in_start, GlyphPoint const & in_intermediate, GlyphPoint const & in_end);
35618 
35622  bool ShowStartPoint(GlyphPoint & out_point) const;
35623 
35627  bool ShowIntermediatePoint(GlyphPoint & out_point) const;
35628 
35632  bool ShowEndPoint(GlyphPoint & out_point) const;
35633 };
35634 
35635 
35636 
35639 {
35640 public:
35643 
35648  InfiniteLineGlyphElement(GlyphElement const & in_that);
35649 
35653 
35658  InfiniteLineGlyphElement(GlyphPoint const & in_first, GlyphPoint const & in_second, InfiniteLine::Type in_type = InfiniteLine::Type::Line);
35659 
35664 
35668  InfiniteLineGlyphElement & operator=(InfiniteLineGlyphElement && in_that);
35669 
35671 
35672  HPS::Type ObjectType() const { return HPS::Type::InfiniteLineGlyphElement; };
35673 
35676  void SetFirstPoint(GlyphPoint const & in_point);
35677 
35680  void SetSecondPoint(GlyphPoint const & in_point);
35681 
35685  void SetPoints(GlyphPoint const & in_first, GlyphPoint const & in_second);
35686 
35689  void SetInfiniteType(InfiniteLine::Type in_type);
35690 
35694  bool ShowFirstPoint(GlyphPoint & out_point) const;
35695 
35699  bool ShowSecondPoint(GlyphPoint & out_point) const;
35700 
35704  bool ShowInfiniteType(InfiniteLine::Type & out_type) const;
35705 };
35706 
35707 
35708 
35710 class HPS_API GlyphKit : public Object
35711 {
35712 public:
35714  GlyphKit();
35715 
35718  GlyphKit(GlyphKit const & in_kit);
35719 
35723  GlyphKit(GlyphKit && in_that);
35724 
35728  GlyphKit & operator=(GlyphKit && in_that);
35729 
35730  virtual ~GlyphKit();
35731 
35732  HPS::Type ObjectType() const { return HPS::Type::GlyphKit; };
35733 
35737  static HPS::GlyphKit GetDefault(Glyph::Default in_default_glyph);
35738 
35741  void Set(GlyphKit const & in_kit);
35742 
35745  void Show(GlyphKit & out_kit) const;
35746 
35750  GlyphKit & operator=(GlyphKit const & in_kit);
35751 
35754  bool Empty() const;
35755 
35759  bool Equals(GlyphKit const & in_kit) const;
35760 
35764  bool operator==(GlyphKit const & in_kit) const;
35765 
35769  bool operator!=(GlyphKit const & in_kit) const;
35770 
35774  GlyphKit & SetRadius(sbyte in_radius);
35775 
35780  GlyphKit & SetOffset(GlyphPoint const & in_point);
35781 
35785  GlyphKit & SetElements(GlyphElementArray const & in_def);
35786 
35791  GlyphKit & SetElements(size_t in_count, GlyphElement const in_def []);
35792 
35795  GlyphKit & UnsetRadius();
35796 
35799  GlyphKit & UnsetOffset();
35800 
35803  GlyphKit & UnsetElements();
35804 
35807  GlyphKit & UnsetEverything();
35808 
35812  bool ShowRadius(sbyte & out_radius) const;
35813 
35817  bool ShowOffset(GlyphPoint & out_point) const;
35818 
35822  bool ShowElements(GlyphElementArray & out_def) const;
35823 };
35824 
35828 
35829 
35832 class HPS_API LinePatternOptionsKit : public Object
35833 {
35834 public:
35837 
35841 
35846 
35850  LinePatternOptionsKit & operator=(LinePatternOptionsKit && in_that);
35851 
35852  virtual ~LinePatternOptionsKit();
35853 
35854  HPS::Type ObjectType() const { return HPS::Type::LinePatternOptionsKit; };
35855 
35858  void Set(LinePatternOptionsKit const & in_kit);
35859 
35862  void Show(LinePatternOptionsKit & out_kit) const;
35863 
35867  LinePatternOptionsKit & operator=(LinePatternOptionsKit const & in_kit);
35868 
35871  bool Empty() const;
35872 
35876  bool Equals(LinePatternOptionsKit const & in_kit) const;
35877 
35881  bool operator==(LinePatternOptionsKit const & in_kit) const;
35882 
35886  bool operator!=(LinePatternOptionsKit const & in_kit) const;
35887 
35891  LinePatternOptionsKit & SetStartCap(char const * in_glyph);
35892 
35896  LinePatternOptionsKit & SetStartCap(LinePattern::Cap in_type);
35897 
35901  LinePatternOptionsKit & SetEndCap(char const * in_glyph);
35902 
35906  LinePatternOptionsKit & SetEndCap(LinePattern::Cap in_type);
35907 
35911  LinePatternOptionsKit & SetInnerCap(LinePattern::Cap in_type);
35912 
35916  LinePatternOptionsKit & SetJoin(char const * in_glyph);
35917 
35921  LinePatternOptionsKit & SetJoin(LinePattern::Join in_type);
35922 
35926  LinePatternOptionsKit & UnsetStartCap();
35927 
35931  LinePatternOptionsKit & UnsetEndCap();
35932 
35935  LinePatternOptionsKit & UnsetInnerCap();
35936 
35940  LinePatternOptionsKit & UnsetJoin();
35941 
35944  LinePatternOptionsKit & UnsetEverything();
35945 
35951  bool ShowStartCap(LinePattern::Modifier & out_modifier, UTF8 & out_glyph, LinePattern::Cap & out_type) const;
35952 
35958  bool ShowEndCap(LinePattern::Modifier & out_modifier, UTF8 & out_glyph, LinePattern::Cap & out_type) const;
35959 
35963  bool ShowInnerCap(LinePattern::Cap & out_type) const;
35964 
35970  bool ShowJoin(LinePattern::Modifier & out_modifier, UTF8 & out_glyph, LinePattern::Join & out_type) const;
35971 };
35972 
35975 class HPS_API LinePatternElement : public Object
35976 {
35977 public:
35980 
35983  LinePatternElement(LinePatternElement const & in_that);
35984 
35989 
35993  LinePatternElement & operator=(LinePatternElement && in_that);
35994 
35995  ~LinePatternElement();
35996 
35997  HPS::Type ObjectType() const { return HPS::Type::LinePatternElement; };
35998 
36001  void Set(LinePatternElement const & in_that);
36002 
36006  LinePatternElement & operator=(LinePatternElement const & in_that);
36007 
36011  bool Equals(LinePatternElement const & in_that) const;
36012 
36016  bool operator==(LinePatternElement const & in_that) const;
36017 
36021  bool operator!=(LinePatternElement const & in_that) const;
36022 
36026  void SetSize(float in_size, LinePattern::SizeUnits in_units);
36027 
36032  bool ShowSize(float & out_size, LinePattern::SizeUnits & out_units) const;
36033 };
36034 
36037 {
36038 public:
36041 
36047 
36051 
36055  SolidLinePatternElement(float in_size, LinePattern::SizeUnits in_units);
36056 
36061 
36065  SolidLinePatternElement & operator=(SolidLinePatternElement && in_that);
36066 
36068 
36069  HPS::Type ObjectType() const { return HPS::Type::SolidLinePatternElement; };
36070 
36074  void SetColor(RGBAColor const & in_color);
36075 
36079  void SetMaterialByIndex(float in_material_index);
36080 
36086  bool ShowColor(Material::Type & out_type, RGBAColor & out_color, float & out_index) const;
36087 };
36088 
36089 
36092 {
36093 public:
36096 
36102 
36106 
36110  BlankLinePatternElement(float in_size, LinePattern::SizeUnits in_units);
36111 
36116 
36120  BlankLinePatternElement & operator=(BlankLinePatternElement && in_that);
36121 
36123 
36124  HPS::Type ObjectType() const { return HPS::Type::BlankLinePatternElement; };
36125 };
36126 
36127 
36130 {
36131 public:
36134 
36140 
36144 
36148  GlyphLinePatternElement & operator=(GlyphLinePatternElement const & in_that);
36149 
36154 
36158  GlyphLinePatternElement & operator=(GlyphLinePatternElement && in_that);
36159 
36161 
36162  HPS::Type ObjectType() const { return HPS::Type::GlyphLinePatternElement; };
36163 
36166  void SetSource(char const * in_source);
36167 
36171  void SetWeight(float in_weight, LinePattern::SizeUnits in_units);
36172 
36175  void SetInsetBehavior(LinePattern::InsetBehavior in_behavior);
36176 
36179  void SetMirror(bool in_state);
36180 
36183  void SetFixed(bool in_state);
36184 
36187  void SetRotation(float in_degrees);
36188 
36192  bool ShowSource(UTF8 & out_source) const;
36193 
36198  bool ShowWeight(float & out_weight, LinePattern::SizeUnits & out_units) const;
36199 
36203  bool ShowInsetBehavior(LinePattern::InsetBehavior & out_behavior) const;
36204 
36208  bool ShowMirror(bool & out_state) const;
36209 
36213  bool ShowFixed(bool & out_state) const;
36214 
36218  bool ShowRotation(float & out_degrees) const;
36219 };
36220 
36222 class HPS_API LinePatternParallelKit : public Object
36223 {
36224 public:
36227 
36231 
36236 
36240  LinePatternParallelKit & operator=(LinePatternParallelKit && in_that);
36241 
36242  virtual ~LinePatternParallelKit();
36243 
36244  HPS::Type ObjectType() const { return HPS::Type::LinePatternParallelKit; };
36245 
36248  void Set(LinePatternParallelKit const & in_kit);
36249 
36252  void Show(LinePatternParallelKit & out_kit) const;
36253 
36257  LinePatternParallelKit & operator=(LinePatternParallelKit const & in_kit);
36258 
36261  bool Empty() const;
36262 
36266  bool Equals(LinePatternParallelKit const & in_kit) const;
36267 
36271  bool operator==(LinePatternParallelKit const & in_kit) const;
36272 
36276  bool operator!=(LinePatternParallelKit const & in_kit) const;
36277 
36281  LinePatternParallelKit & SetStartCap(GlyphLinePatternElement const & in_start);
36282 
36286  LinePatternParallelKit & SetEndCap(GlyphLinePatternElement const & in_end);
36287 
36291  LinePatternParallelKit & SetJoin(GlyphLinePatternElement const & in_join);
36292 
36296  LinePatternParallelKit & SetBody(LinePatternElementArray const & in_elements);
36297 
36302  LinePatternParallelKit & SetBody(size_t in_count, LinePatternElement const in_elements []);
36303 
36307  LinePatternParallelKit & SetAbsoluteLength(bool in_state);
36308 
36312  LinePatternParallelKit & SetAbsoluteWeight(bool in_state);
36313 
36317  LinePatternParallelKit & SetJustification(LinePattern::Justification in_type);
36318 
36325  LinePatternParallelKit & SetOffset(float in_offset, LinePattern::SizeUnits in_units, bool in_fixed = false);
36326 
36332  LinePatternParallelKit & SetWeight(float in_weight, LinePattern::SizeUnits in_units, bool in_fixed = false);
36333 
36337  LinePatternParallelKit & SetContinuous(bool in_state);
36338 
36341  LinePatternParallelKit & UnsetStartCap();
36342 
36345  LinePatternParallelKit & UnsetEndCap();
36346 
36349  LinePatternParallelKit & UnsetJoin();
36350 
36353  LinePatternParallelKit & UnsetBody();
36354 
36357  LinePatternParallelKit & UnsetAbsoluteLength();
36358 
36361  LinePatternParallelKit & UnsetAbsoluteWeight();
36362 
36365  LinePatternParallelKit & UnsetJustification();
36366 
36369  LinePatternParallelKit & UnsetOffset();
36370 
36373  LinePatternParallelKit & UnsetWeight();
36374 
36377  LinePatternParallelKit & UnsetContinuous();
36378 
36381  LinePatternParallelKit & UnsetEverything();
36382 
36386  bool ShowStartCap(GlyphLinePatternElement & out_start) const;
36387 
36391  bool ShowEndCap(GlyphLinePatternElement & out_end) const;
36392 
36396  bool ShowJoin(GlyphLinePatternElement & out_join) const;
36397 
36401  bool ShowBody(LinePatternElementArray & out_elements) const;
36402 
36406  bool ShowAbsoluteLength(bool & out_state) const;
36407 
36411  bool ShowAbsoluteWeight(bool & out_state) const;
36412 
36416  bool ShowJustification(LinePattern::Justification & out_type) const;
36417 
36423  bool ShowOffset(float & out_offset, LinePattern::SizeUnits & out_units, bool & out_fixed) const;
36424 
36430  bool ShowWeight(float & out_weight, LinePattern::SizeUnits & out_units, bool & out_fixed) const;
36431 
36435  bool ShowContinuous(bool & out_state) const;
36436 };
36437 
36438 
36440 class HPS_API LinePatternKit : public Object
36441 {
36442 public:
36444  LinePatternKit();
36445 
36448  LinePatternKit(LinePatternKit const & in_kit);
36449 
36453  LinePatternKit(LinePatternKit && in_that);
36454 
36458  LinePatternKit & operator=(LinePatternKit && in_that);
36459 
36460  virtual ~LinePatternKit();
36461 
36462  HPS::Type ObjectType() const { return HPS::Type::LinePatternKit; };
36463 
36467  static HPS::LinePatternKit GetDefault(LinePattern::Default in_default_line_pattern);
36468 
36471  void Set(LinePatternKit const & in_kit);
36472 
36475  void Show(LinePatternKit & out_kit) const;
36476 
36480  LinePatternKit & operator=(LinePatternKit const & in_kit);
36481 
36484  bool Empty() const;
36485 
36489  bool Equals(LinePatternKit const & in_kit) const;
36490 
36494  bool operator==(LinePatternKit const & in_kit) const;
36495 
36499  bool operator!=(LinePatternKit const & in_kit) const;
36500 
36504  LinePatternKit & SetParallels(LinePatternParallelKitArray const & in_parallels);
36505 
36510  LinePatternKit & SetParallels(size_t in_count, LinePatternParallelKit const in_parallels []);
36511 
36515  LinePatternKit & SetJoin(LinePattern::Join in_type);
36516 
36519  LinePatternKit & UnsetParallels();
36520 
36523  LinePatternKit & UnsetJoin();
36524 
36527  LinePatternKit & UnsetEverything();
36528 
36532  bool ShowParallels(LinePatternParallelKitArray & out_parallels) const;
36533 
36537  bool ShowJoin(LinePattern::Join & out_type) const;
36538 };
36539 
36540 
36541 
36545 
36546 
36548 class HPS_API Definition : public Object
36549 {
36550 public:
36552  Definition();
36553 
36556  Definition(Definition const & in_that);
36557 
36561  Definition & operator=(Definition const & in_that);
36562 
36566  Definition(Definition && in_that);
36567 
36571  Definition & operator=(Definition && in_that);
36572 
36573  virtual ~Definition();
36574 
36575  HPS::Type ObjectType() const { return HPS::Type::Definition; };
36576 
36578  void Undefine();
36579 
36582  PortfolioKey Owner() const;
36583 
36586  UTF8 Name() const;
36587 
36590  virtual void Assign(Definition const & in_that);
36591 
36595  bool Equals(Definition const & in_that) const;
36596 
36600  bool operator==(Definition const & in_that) const;
36601 
36605  bool operator!=(Definition const & in_that) const;
36606 };
36607 
36608 
36611 class HPS_API PortfolioKey : public Key
36612 {
36613 public:
36615  PortfolioKey();
36616 
36621  explicit PortfolioKey(Key const & in_that);
36622 
36625  PortfolioKey(PortfolioKey const & in_that);
36626 
36630  PortfolioKey & operator=(PortfolioKey const & in_that);
36631 
36635  PortfolioKey(PortfolioKey && in_that);
36636 
36640  PortfolioKey & operator=(PortfolioKey && in_that);
36641 
36642  ~PortfolioKey();
36643 
36644  HPS::Type ObjectType() const { return HPS::Type::PortfolioKey; };
36645 
36646  // Define
36647 
36654  TextureDefinition DefineTexture(char const * in_name, ImageDefinition const & in_source);
36655 
36663  TextureDefinition DefineTexture(char const * in_name, ImageDefinition const & in_source, TextureOptionsKit const & in_options);
36664 
36665 
36677  CubeMapDefinition DefineCubeMap(char const * in_name, ImageDefinition const & in_negative_z, ImageDefinition const & in_positive_z,
36678  ImageDefinition const & in_negative_x, ImageDefinition const & in_positive_x,
36679  ImageDefinition const & in_negative_y, ImageDefinition const & in_positive_y);
36680 
36693  CubeMapDefinition DefineCubeMap(char const * in_name, ImageDefinition const & in_negative_z, ImageDefinition const & in_positive_z,
36694  ImageDefinition const & in_negative_x, ImageDefinition const & in_positive_x,
36695  ImageDefinition const & in_negative_y, ImageDefinition const & in_positive_y, TextureOptionsKit const & in_options);
36696 
36697 
36703  ImageDefinition DefineImage(char const * in_name, ImageKit const & in_source);
36704 
36705 
36711  NamedStyleDefinition DefineNamedStyle(char const * in_name, SegmentKey const & in_style_source);
36712 
36713 
36719  MaterialPaletteDefinition DefineMaterialPalette(char const * in_name, MaterialKitArray const & in_source);
36720 
36727  MaterialPaletteDefinition DefineMaterialPalette(char const * in_name, size_t in_count, MaterialKit const in_source []);
36728 
36729 
36735  GlyphDefinition DefineGlyph(char const * in_name, GlyphKit const & in_source);
36736 
36737 
36743  LinePatternDefinition DefineLinePattern(char const * in_name, LinePatternKit const & in_source);
36744 
36745 
36751  ShaderDefinition DefineShader(char const * in_name, ShaderKit const & in_source);
36752 
36753 
36754  // UnDefine
36755 
36759  PortfolioKey & UndefineTexture(char const * in_name);
36760 
36764  PortfolioKey & UndefineCubeMap(char const * in_name);
36765 
36769  PortfolioKey & UndefineImage(char const * in_name);
36770 
36774  PortfolioKey & UndefineNamedStyle(char const * in_name);
36775 
36779  PortfolioKey & UndefineMaterialPalette(char const * in_name);
36780 
36784  PortfolioKey & UndefineGlyph(char const * in_name);
36785 
36789  PortfolioKey & UndefineLinePattern(char const * in_name);
36790 
36794  PortfolioKey & UndefineShader(char const * in_name);
36795 
36796 
36797  // Import collections
36803  PortfolioKey & ImportPortfolio(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
36804 
36805 
36811  PortfolioKey & ImportAllTextures(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
36812 
36818  PortfolioKey & ImportAllCubeMaps(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
36819 
36825  PortfolioKey & ImportAllImages(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
36826 
36832  PortfolioKey & ImportAllNamedStyles(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
36833 
36839  PortfolioKey & ImportAllMaterialPalettes(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
36840 
36846  PortfolioKey & ImportAllGlyphs(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
36847 
36853  PortfolioKey & ImportAllLinePatterns(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
36854 
36860  PortfolioKey & ImportAllShaders(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
36861 
36862 
36863  // Import individual definitions
36867  TextureDefinition ImportTexture(TextureDefinition const & in_definition);
36868 
36872  CubeMapDefinition ImportCubeMap(CubeMapDefinition const & in_definition);
36873 
36877  ImageDefinition ImportImage(ImageDefinition const & in_definition);
36878 
36882  NamedStyleDefinition ImportNamedStyle(NamedStyleDefinition const & in_definition);
36883 
36887  MaterialPaletteDefinition ImportMaterialPalette(MaterialPaletteDefinition const & in_definition);
36888 
36892  GlyphDefinition ImportGlyph(GlyphDefinition const & in_definition);
36893 
36897  LinePatternDefinition ImportLinePattern(LinePatternDefinition const & in_definition);
36898 
36902  ShaderDefinition ImportShader(ShaderDefinition const & in_definition);
36903 
36904 
36905  // Show
36907  size_t GetDefinitionCount() const;
36908 
36910  size_t GetTextureDefinitionCount() const;
36911 
36913  size_t GetCubeMapDefinitionCount() const;
36914 
36916  size_t GetImageDefinitionCount() const;
36917 
36919  size_t GetNamedStyleDefinitionCount() const;
36920 
36922  size_t GetMaterialPaletteDefinitionCount() const;
36923 
36925  size_t GetGlyphDefinitionCount() const;
36926 
36928  size_t GetLinePatternDefinitionCount() const;
36929 
36932  size_t GetShaderDefinitionCount() const;
36933 
36938  bool ShowTextureDefinition(char const * in_name, TextureDefinition & out_found) const;
36939 
36943  bool ShowAllTextureDefinitions(TextureDefinitionArray & out_definitions) const;
36944 
36949  bool ShowCubeMapDefinition(char const * in_name, CubeMapDefinition & out_found) const;
36950 
36954  bool ShowAllCubeMapDefinitions(CubeMapDefinitionArray & out_definitions) const;
36955 
36960  bool ShowImageDefinition(char const * in_name, ImageDefinition & out_found) const;
36961 
36965  bool ShowAllImageDefinitions(ImageDefinitionArray & out_definitions) const;
36966 
36971  bool ShowNamedStyleDefinition(char const * in_name, NamedStyleDefinition & out_found) const;
36972 
36976  bool ShowAllNamedStyleDefinitions(NamedStyleDefinitionArray & out_definitions) const;
36977 
36982  bool ShowMaterialPaletteDefinition(char const * in_name, MaterialPaletteDefinition & out_found) const;
36983 
36987  bool ShowAllMaterialPaletteDefinitions(MaterialPaletteDefinitionArray & out_definitions) const;
36988 
36993  bool ShowGlyphDefinition(char const * in_name, GlyphDefinition & out_found) const;
36994 
36998  bool ShowAllGlyphDefinitions(GlyphDefinitionArray & out_definitions) const;
36999 
37004  bool ShowLinePatternDefinition(char const * in_name, LinePatternDefinition & out_found) const;
37005 
37009  bool ShowAllLinePatternDefinitions(LinePatternDefinitionArray & out_definitions) const;
37010 
37015  bool ShowShaderDefinition(char const * in_name, ShaderDefinition & out_found) const;
37016 
37020  bool ShowAllShaderDefinitions(ShaderDefinitionArray & out_definitions) const;
37021 
37022 private:
37024  void MoveTo(SegmentKey const & in_new_owner);
37025 
37027  Key CopyTo(SegmentKey const & in_destination) const;
37028 };
37029 
37030 
37031 
37033 class HPS_API GlyphDefinition : public Definition
37034 {
37035 public:
37037  GlyphDefinition();
37038 
37043  GlyphDefinition(Definition const & in_that);
37044 
37047  GlyphDefinition(GlyphDefinition const & in_that);
37048 
37052  GlyphDefinition & operator=(GlyphDefinition const & in_that);
37053 
37057  GlyphDefinition(GlyphDefinition && in_that);
37058 
37062  GlyphDefinition & operator=(GlyphDefinition && in_that);
37063 
37064  ~GlyphDefinition();
37065 
37066  HPS::Type ObjectType() const { return HPS::Type::GlyphDefinition; };
37067 
37070  void Set(GlyphKit const & in_kit);
37071 
37074  void Show(GlyphKit & out_kit) const;
37075 };
37076 
37077 
37079 class HPS_API TextureDefinition : public Definition
37080 {
37081 public:
37084 
37089  TextureDefinition(Definition const & in_that);
37090 
37093  TextureDefinition(TextureDefinition const & in_that);
37094 
37098  TextureDefinition & operator=(TextureDefinition const & in_that);
37099 
37104 
37108  TextureDefinition & operator=(TextureDefinition && in_that);
37109 
37110  ~TextureDefinition();
37111 
37112  HPS::Type ObjectType() const { return HPS::Type::TextureDefinition; };
37113 
37116  void SetSource(ImageDefinition const & in_source);
37117 
37120  void ShowSource(ImageDefinition & out_source) const;
37121 
37124  void SetOptions(TextureOptionsKit const & in_options);
37125 
37128  void ShowOptions(TextureOptionsKit & out_options) const;
37129 
37130 };
37131 
37135 class HPS_API TextureOptionsKit : public Object
37136 {
37137 public:
37140 
37143  TextureOptionsKit(TextureOptionsKit const & in_kit);
37144 
37149 
37153  TextureOptionsKit & operator=(TextureOptionsKit && in_that);
37154 
37155  virtual ~TextureOptionsKit();
37156 
37157  HPS::Type ObjectType() const { return HPS::Type::TextureOptionsKit; };
37158 
37162  static TextureOptionsKit GetDefault();
37163 
37166  void Set(TextureOptionsKit const & in_kit);
37167 
37170  void Show(TextureOptionsKit & out_kit) const;
37171 
37175  TextureOptionsKit & operator=(TextureOptionsKit const & in_kit);
37176 
37179  bool Empty() const;
37180 
37184  bool Equals(TextureOptionsKit const & in_kit) const;
37185 
37189  bool operator==(TextureOptionsKit const & in_kit) const;
37190 
37194  bool operator!=(TextureOptionsKit const & in_kit) const;
37195 
37200  TextureOptionsKit & SetDecal(bool in_state);
37201 
37205  TextureOptionsKit & SetDownSampling(bool in_state);
37206 
37210  TextureOptionsKit & SetModulation(bool in_state);
37211 
37215  TextureOptionsKit & SetParameterOffset(size_t in_offset);
37216 
37220  TextureOptionsKit & SetParameterizationSource(Material::Texture::Parameterization in_source);
37221 
37225  TextureOptionsKit & SetTiling(Material::Texture::Tiling in_tiling);
37226 
37230  TextureOptionsKit & SetInterpolationFilter(Material::Texture::Interpolation in_filter);
37231 
37235  TextureOptionsKit & SetDecimationFilter(Material::Texture::Decimation in_filter);
37236 
37240  TextureOptionsKit & SetTransformMatrix(MatrixKit const & in_transform);
37241 
37244  TextureOptionsKit & UnsetDecal();
37245 
37248  TextureOptionsKit & UnsetDownSampling();
37249 
37252  TextureOptionsKit & UnsetModulation();
37253 
37256  TextureOptionsKit & UnsetParameterOffset();
37257 
37260  TextureOptionsKit & UnsetParameterizationSource();
37261 
37264  TextureOptionsKit & UnsetTiling();
37265 
37268  TextureOptionsKit & UnsetInterpolationFilter();
37269 
37272  TextureOptionsKit & UnsetDecimationFilter();
37273 
37276  TextureOptionsKit & UnsetTransformMatrix();
37277 
37280  TextureOptionsKit & UnsetEverything();
37281 
37285  bool ShowDecal(bool & out_state) const;
37286 
37290  bool ShowDownSampling(bool & out_state) const;
37291 
37295  bool ShowModulation(bool & out_state) const;
37296 
37300  bool ShowParameterOffset(size_t & out_offset) const;
37301 
37305  bool ShowParameterizationSource(Material::Texture::Parameterization & out_source) const;
37306 
37310  bool ShowTiling(Material::Texture::Tiling & out_tiling) const;
37311 
37315  bool ShowInterpolationFilter(Material::Texture::Interpolation & out_filter) const;
37316 
37320  bool ShowDecimationFilter(Material::Texture::Decimation & out_filter) const;
37321 
37325  bool ShowTransformMatrix(MatrixKit & out_transform) const;
37326 };
37327 
37328 
37330 class HPS_API Image
37331 {
37332 public:
37335  enum class Format
37336  {
37337  RGB,
37338  RGBA,
37339  ARGB,
37340  Mapped8,
37341  Grayscale,
37342  Bmp,
37343  Jpeg,
37344  Png,
37345  Targa,
37346  DXT1,
37347  DXT3,
37348  DXT5
37349  };
37350 
37352  class HPS_API ExportOptionsKit : public Object
37353  {
37354  public:
37356  ExportOptionsKit();
37357 
37360  ExportOptionsKit(ExportOptionsKit const & in_kit);
37361 
37365  ExportOptionsKit(ExportOptionsKit && in_that);
37366 
37370  ExportOptionsKit & operator=(ExportOptionsKit && in_that);
37371 
37372  virtual ~ExportOptionsKit();
37373 
37374  HPS::Type ObjectType() const { return HPS::Type::ImageExportOptionsKit; };
37375 
37379  static ExportOptionsKit GetDefault();
37380 
37383  void Set(ExportOptionsKit const & in_kit);
37384 
37387  void Show(ExportOptionsKit & out_kit) const;
37388 
37392  ExportOptionsKit & operator=(ExportOptionsKit const & in_kit);
37393 
37396  bool Empty() const;
37397 
37401  bool Equals(ExportOptionsKit const & in_kit) const;
37402 
37406  bool operator==(ExportOptionsKit const & in_kit) const;
37407 
37411  bool operator!=(ExportOptionsKit const & in_kit) const;
37412 
37417  ExportOptionsKit & SetSize(unsigned int in_width, unsigned int in_height);
37418 
37423  ExportOptionsKit & SetFormat(Image::Format in_format);
37424 
37427  ExportOptionsKit & UnsetSize();
37428 
37431  ExportOptionsKit & UnsetFormat();
37432 
37435  ExportOptionsKit & UnsetEverything();
37436 
37441  bool ShowSize(unsigned int & out_width, unsigned int & out_height) const;
37442 
37446  bool ShowFormat(Image::Format & out_format) const;
37447  };
37448 
37450  class HPS_API ImportOptionsKit : public Object
37451  {
37452  public:
37454  ImportOptionsKit();
37455 
37458  ImportOptionsKit(ImportOptionsKit const & in_kit);
37459 
37463  ImportOptionsKit(ImportOptionsKit && in_that);
37464 
37468  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
37469 
37470  virtual ~ImportOptionsKit();
37471 
37472  HPS::Type ObjectType() const { return HPS::Type::ImageImportOptionsKit; };
37473 
37476  void Set(ImportOptionsKit const & in_kit);
37477 
37480  void Show(ImportOptionsKit & out_kit) const;
37481 
37485  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
37486 
37489  bool Empty() const;
37490 
37494  bool Equals(ImportOptionsKit const & in_kit) const;
37495 
37499  bool operator==(ImportOptionsKit const & in_kit) const;
37500 
37504  bool operator!=(ImportOptionsKit const & in_kit) const;
37505 
37512  ImportOptionsKit & SetSize(unsigned int in_width, unsigned int in_height);
37513 
37517  ImportOptionsKit & SetFormat(Image::Format in_format);
37518 
37523  ImportOptionsKit & SetDownSampling(bool in_state);
37524 
37529  ImportOptionsKit & SetCompressionQuality(float in_quality);
37530 
37533  ImportOptionsKit & UnsetSize();
37534 
37537  ImportOptionsKit & UnsetFormat();
37538 
37541  ImportOptionsKit & UnsetDownSampling();
37542 
37545  ImportOptionsKit & UnsetCompressionQuality();
37546 
37549  ImportOptionsKit & UnsetEverything();
37550 
37555  bool ShowSize(unsigned int & out_width, unsigned int & out_height) const;
37556 
37560  bool ShowFormat(Image::Format & out_format) const;
37561 
37565  bool ShowDownSampling(bool & out_state) const;
37566 
37570  bool ShowCompressionQuality(float & out_quality) const;
37571  };
37572 
37574  class HPS_API File
37575  {
37576  public:
37582  static ImageKit Import(char const * in_file_name, ImportOptionsKit const & in_options);
37583 
37590  static void Export(char const * in_file_name, HPS::WindowKey const & in_window, ExportOptionsKit const & in_options);
37591 
37599  static void Export(char const * in_file_name, HPS::WindowKey const & in_window, unsigned int in_width, unsigned int in_height, Format in_format = Format::Png);
37600 
37605  static void Export(char const * in_file_name, HPS::ImageKit const & in_image_kit);
37606 
37607  private:
37609  File();
37610  };
37611 
37612 private:
37614  Image();
37615 };
37616 
37617 
37619 class HPS_API ImageKit : public Object
37620 {
37621 public:
37623  ImageKit();
37624 
37627  ImageKit(ImageKit const & in_kit);
37628 
37633  ImageKit(ImageKit const & in_kit, HPS::Image::Format in_format);
37634 
37638  ImageKit(ImageKit && in_that);
37639 
37643  ImageKit & operator=(ImageKit && in_that);
37644 
37645  virtual ~ImageKit();
37646 
37647  HPS::Type ObjectType() const { return HPS::Type::ImageKit; };
37648 
37651  void Set(ImageKit const & in_kit);
37652 
37655  void Show(ImageKit & out_kit) const;
37656 
37660  ImageKit & operator=(ImageKit const & in_kit);
37661 
37664  bool Empty() const;
37665 
37669  bool Equals(ImageKit const & in_kit) const;
37670 
37674  bool operator==(ImageKit const & in_kit) const;
37675 
37679  bool operator!=(ImageKit const & in_kit) const;
37680 
37684  void Convert(ImageKit const & in_kit, HPS::Image::Format in_format);
37685 
37688  void Convert(HPS::Image::Format in_format);
37689 
37694  ImageKit & SetSize(unsigned int in_width, unsigned int in_height);
37695 
37699  ImageKit & SetData(ByteArray const & in_image_data);
37700 
37705  ImageKit & SetData(size_t in_byte_count, byte const in_image_data []);
37706 
37710  ImageKit & SetFormat(Image::Format in_format);
37711 
37715  ImageKit & SetDownSampling(bool in_state);
37716 
37720  ImageKit & SetCompressionQuality(float in_quality);
37721 
37724  ImageKit & UnsetSize();
37725 
37728  ImageKit & UnsetData();
37729 
37732  ImageKit & UnsetFormat();
37733 
37736  ImageKit & UnsetDownSampling();
37737 
37740  ImageKit & UnsetCompressionQuality();
37741 
37744  ImageKit & UnsetEverything();
37745 
37750  bool ShowSize(unsigned int & out_width, unsigned int & out_height) const;
37751 
37755  bool ShowData(ByteArray & out_image_data) const;
37756 
37760  bool ShowFormat(Image::Format & out_format) const;
37761 
37765  bool ShowDownSampling(bool & out_state) const;
37766 
37770  bool ShowCompressionQuality(float & out_quality) const;
37771 };
37772 
37773 
37779 {
37780 public:
37784 
37789 
37794 
37799 
37801 
37802  HPS::Type ObjectType() const { return HPS::Type::OffScreenWindowOptionsControl; };
37803 
37807  OffScreenWindowOptionsControl & operator=(OffScreenWindowOptionsControl const & in_that);
37808 
37813  OffScreenWindowOptionsControl & SetSize(unsigned int in_width, unsigned int in_height);
37814 
37819  OffScreenWindowOptionsControl & SetNativeFormat(Window::ImageFormat in_format, float in_quality = 1.0f);
37820 
37824  bool ShowDriver(Window::Driver & out_driver) const;
37825 
37830  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
37831 
37836  bool ShowSize(unsigned int & out_width, unsigned int & out_height) const;
37837 
37842  bool ShowImage(Image::Format in_format, ImageKit & out_image) const;
37843 
37848  bool ShowImage(ByteArray & out_bytes) const;
37849 
37853  bool ShowHardwareResident(bool & out_state) const;
37854 
37859  bool ShowOpacity(bool & out_state, float & out_opacity) const;
37860 
37865  bool ShowNativeFormat(Window::ImageFormat & out_format, float & out_quality) const;
37866 
37867 
37868 private:
37871 };
37872 
37873 
37876 class HPS_API OffScreenWindowKey : public WindowKey
37877 {
37878 public:
37881 
37886  OffScreenWindowKey(Key const & in_key);
37887 
37890  OffScreenWindowKey(OffScreenWindowKey const & in_that);
37891 
37896 
37900  OffScreenWindowKey & operator=(OffScreenWindowKey && in_that);
37901 
37902  ~OffScreenWindowKey();
37903 
37904  HPS::Type ObjectType() const { return HPS::Type::OffScreenWindowKey; };
37905 
37908  OffScreenWindowOptionsControl const GetWindowOptionsControl() const;
37909 
37912  OffScreenWindowOptionsControl GetWindowOptionsControl();
37913 
37917  bool ShowWindowOptions(OffScreenWindowOptionsKit & out_kit) const;
37918 };
37919 
37920 
37921 
37922 
37924 class HPS_API ImageDefinition : public Definition
37925 {
37926 public:
37928  ImageDefinition();
37929 
37934  ImageDefinition(Definition const & in_that);
37935 
37938  ImageDefinition(ImageDefinition const & in_that);
37939 
37943  ImageDefinition & operator=(ImageDefinition const & in_that);
37944 
37948  ImageDefinition(ImageDefinition && in_that);
37949 
37953  ImageDefinition & operator=(ImageDefinition && in_that);
37954 
37955  ~ImageDefinition();
37956 
37957  HPS::Type ObjectType() const { return HPS::Type::ImageDefinition; };
37958 
37961  void Set(ImageKit const & in_kit);
37962 
37965  void Show(ImageKit & out_kit) const;
37966 };
37967 
37969 class HPS_API CubeMapDefinition : public Definition
37970 {
37971 public:
37974 
37979  CubeMapDefinition(Definition const & in_that);
37980 
37983  CubeMapDefinition(CubeMapDefinition const & in_that);
37984 
37988  CubeMapDefinition & operator=(CubeMapDefinition const & in_that);
37989 
37994 
37998  CubeMapDefinition & operator=(CubeMapDefinition && in_that);
37999 
38000  ~CubeMapDefinition();
38001 
38002  HPS::Type ObjectType() const { return HPS::Type::CubeMapDefinition; };
38003 
38011  void SetSource(ImageDefinition const & in_negative_z, ImageDefinition const & in_positive_z,
38012  ImageDefinition const & in_negative_x, ImageDefinition const & in_positive_x,
38013  ImageDefinition const & in_negative_y, ImageDefinition const & in_positive_y);
38014 
38022  void ShowSource(ImageDefinition & out_negative_z, ImageDefinition & out_positive_z,
38023  ImageDefinition & out_negative_x, ImageDefinition & out_positive_x,
38024  ImageDefinition & out_negative_y, ImageDefinition & out_positive_y) const;
38025 
38029  void ShowSource(ImageDefinitionArray & out_image_sources) const;
38030 
38033  void SetOptions(TextureOptionsKit const & in_options);
38034 
38037  void ShowOptions(TextureOptionsKit & out_options) const;
38038 };
38039 
38040 
38042 class HPS_API NamedStyleDefinition : public Definition
38043 {
38044 public:
38047 
38052  NamedStyleDefinition(Definition const & in_that);
38053 
38056  NamedStyleDefinition(NamedStyleDefinition const & in_that);
38057 
38061  NamedStyleDefinition & operator=(NamedStyleDefinition const & in_that);
38062 
38067 
38071  NamedStyleDefinition & operator=(NamedStyleDefinition && in_that);
38072 
38074 
38075  HPS::Type ObjectType() const { return HPS::Type::NamedStyleDefinition; };
38076 
38080  SegmentKey GetSource() const;
38081 };
38082 
38083 
38086 {
38087 public:
38090 
38095  MaterialPaletteDefinition(Definition const & in_that);
38096 
38100 
38104  MaterialPaletteDefinition & operator=(MaterialPaletteDefinition const & in_that);
38105 
38110 
38114  MaterialPaletteDefinition & operator=(MaterialPaletteDefinition && in_that);
38115 
38117 
38118  HPS::Type ObjectType() const { return HPS::Type::MaterialPaletteDefinition; };
38119 
38122  void Set(MaterialKitArray const & in_source);
38123 
38127  void Set(size_t in_count, MaterialKit const in_source []);
38128 
38131  void Show(MaterialKitArray & out_source) const;
38132 };
38133 
38134 
38135 
38137 class HPS_API LinePatternDefinition : public Definition
38138 {
38139 public:
38142 
38147  LinePatternDefinition(Definition const & in_that);
38148 
38152 
38156  LinePatternDefinition & operator=(LinePatternDefinition const & in_that);
38157 
38162 
38166  LinePatternDefinition & operator=(LinePatternDefinition && in_that);
38167 
38169 
38170  HPS::Type ObjectType() const { return HPS::Type::LinePatternDefinition; };
38171 
38174  void Set(LinePatternKit const & in_kit);
38175 
38178  void Show(LinePatternKit & out_kit) const;
38179 };
38180 
38181 
38182 
38184 class HPS_API Shader
38185 {
38186 public:
38189  enum class Parameterization
38190  {
38192  Cylinder,
38194  PhysicalReflection,
38196  Object,
38202  NaturalUV,
38204  ReflectionVector,
38206  SurfaceNormal,
38208  Sphere,
38210  UV,
38212  World
38213  };
38214 
38216  class HPS_API ImportOptionsKit : public Object
38217  {
38218  public:
38220  ImportOptionsKit();
38221 
38224  ImportOptionsKit(ImportOptionsKit const & in_kit);
38225 
38229  ImportOptionsKit(ImportOptionsKit && in_that);
38230 
38234  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
38235 
38236  virtual ~ImportOptionsKit();
38237 
38238  HPS::Type ObjectType() const { return HPS::Type::ShaderImportOptionsKit; };
38239 
38242  void Set(ImportOptionsKit const & in_kit);
38243 
38246  void Show(ImportOptionsKit & out_kit) const;
38247 
38251  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
38252 
38255  bool Empty() const;
38256 
38260  bool Equals(ImportOptionsKit const & in_kit) const;
38261 
38265  bool operator==(ImportOptionsKit const & in_kit) const;
38266 
38270  bool operator!=(ImportOptionsKit const & in_kit) const;
38271 
38278  ImportOptionsKit & SetMultitexture(bool in_state);
38279 
38283  ImportOptionsKit & SetParameterizationSource(Parameterization in_source);
38284 
38288  ImportOptionsKit & SetTransformMatrix(MatrixKit const & in_transform);
38289 
38293  ImportOptionsKit & UnsetMultitexture();
38294 
38297  ImportOptionsKit & UnsetParameterizationSource();
38298 
38301  ImportOptionsKit & UnsetTransformMatrix();
38302 
38305  ImportOptionsKit & UnsetEverything();
38306 
38312  bool ShowMultitexture(bool & out_state) const;
38313 
38317  bool ShowParameterizationSource(Parameterization & out_source) const;
38318 
38322  bool ShowTransformMatrix(MatrixKit & out_transform) const;
38323  };
38324 
38326  class HPS_API File
38327  {
38328  public:
38334  static ShaderKit Import(char const * in_file_name, ImportOptionsKit const & in_options);
38335 
38336  private:
38338  File();
38339  };
38340 
38341 private:
38343  Shader();
38344 };
38345 
38346 
38348 class HPS_API ShaderKit : public Object
38349 {
38350 public:
38352  ShaderKit();
38353 
38356  ShaderKit(ShaderKit const & in_kit);
38357 
38361  ShaderKit(ShaderKit && in_that);
38362 
38366  ShaderKit & operator=(ShaderKit && in_that);
38367 
38368  virtual ~ShaderKit();
38369 
38370  HPS::Type ObjectType() const { return HPS::Type::ShaderKit; };
38371 
38374  void Set(ShaderKit const & in_kit);
38375 
38378  void Show(ShaderKit & out_kit) const;
38379 
38383  ShaderKit & operator=(ShaderKit const & in_kit);
38384 
38387  bool Empty() const;
38388 
38392  bool Equals(ShaderKit const & in_kit) const;
38393 
38397  bool operator==(ShaderKit const & in_kit) const;
38398 
38402  bool operator!=(ShaderKit const & in_kit) const;
38403 
38407  ShaderKit & SetSource(char const * in_source);
38408 
38415  ShaderKit & SetMultitexture(bool in_state);
38416 
38420  ShaderKit & SetParameterizationSource(Shader::Parameterization in_source);
38421 
38425  ShaderKit & SetTransformMatrix(MatrixKit const & in_transform);
38426 
38429  ShaderKit & UnsetSource();
38430 
38434  ShaderKit & UnsetMultitexture();
38435 
38438  ShaderKit & UnsetParameterizationSource();
38439 
38442  ShaderKit & UnsetTransformMatrix();
38443 
38446  ShaderKit & UnsetEverything();
38447 
38451  bool ShowSource(UTF8 & out_source) const;
38452 
38458  bool ShowMultitexture(bool & out_state) const;
38459 
38463  bool ShowParameterizationSource(Shader::Parameterization & out_source) const;
38464 
38468  bool ShowTransformMatrix(MatrixKit & out_transform) const;
38469 };
38470 
38471 
38473 class HPS_API ShaderDefinition : public Definition
38474 {
38475 public:
38477  ShaderDefinition();
38478 
38483  ShaderDefinition(Definition const & in_that);
38484 
38487  ShaderDefinition(ShaderDefinition const & in_that);
38488 
38492  ShaderDefinition & operator=(ShaderDefinition const & in_that);
38493 
38497  ShaderDefinition(ShaderDefinition && in_that);
38498 
38502  ShaderDefinition & operator=(ShaderDefinition && in_that);
38503 
38504  ~ShaderDefinition();
38505 
38506  HPS::Type ObjectType() const { return HPS::Type::ShaderDefinition; };
38507 
38510  void Set(ShaderKit const & in_kit);
38511 
38514  void Show(ShaderKit & out_kit) const;
38515 };
38516 
38517 
38518 
38519 
38523 
38525 {
38526 public:
38529 
38533 
38538 
38543 
38544  virtual ~CutGeometryGatheringOptionsKit();
38545 
38546  HPS::Type ObjectType() const {return HPS::Type::CutGeometryGatheringOptionsKit;};
38547 
38551  static CutGeometryGatheringOptionsKit GetDefault();
38552 
38555  void Set(CutGeometryGatheringOptionsKit const & in_kit);
38556 
38559  void Show(CutGeometryGatheringOptionsKit & out_kit) const;
38560 
38565 
38568  bool Empty() const;
38569 
38573  bool Equals(CutGeometryGatheringOptionsKit const & in_kit) const;
38574 
38578  bool operator==(CutGeometryGatheringOptionsKit const & in_kit) const;
38579 
38583  bool operator!=(CutGeometryGatheringOptionsKit const & in_kit) const;
38584 
38585 
38589  CutGeometryGatheringOptionsKit & SetCuttingSection(CuttingSectionKey const & in_cutter);
38590 
38594  CutGeometryGatheringOptionsKit & SetOffset(size_t in_offset);
38595 
38600 
38601 
38604  CutGeometryGatheringOptionsKit & UnsetCuttingSection();
38605 
38608  CutGeometryGatheringOptionsKit & UnsetOffset();
38609 
38612  CutGeometryGatheringOptionsKit & UnsetLevel();
38613 
38616  CutGeometryGatheringOptionsKit & UnsetEverything();
38617 
38618 
38622  bool ShowCuttingSection(CuttingSectionKey & out_cutter) const;
38623 
38627  bool ShowOffset(size_t & out_offset) const;
38628 
38632  bool ShowLevel(CuttingSection::GatheringLevel & out_level) const;
38633 };
38634 
38636 class HPS_API SearchOptionsKit : public Object
38637 {
38638 public:
38640  SearchOptionsKit();
38641 
38644  SearchOptionsKit(SearchOptionsKit const & in_kit);
38645 
38649  SearchOptionsKit(SearchOptionsKit && in_that);
38650 
38654  SearchOptionsKit & operator=(SearchOptionsKit && in_that);
38655 
38656  virtual ~SearchOptionsKit();
38657 
38658  HPS::Type ObjectType() const {return HPS::Type::SearchOptionsKit;};
38659 
38663  static SearchOptionsKit GetDefault();
38664 
38667  void Set(SearchOptionsKit const & in_kit);
38668 
38671  void Show(SearchOptionsKit & out_kit) const;
38672 
38676  SearchOptionsKit & operator=(SearchOptionsKit const & in_kit);
38677 
38680  bool Empty() const;
38681 
38685  bool Equals(SearchOptionsKit const & in_kit) const;
38686 
38690  bool operator==(SearchOptionsKit const & in_kit) const;
38691 
38695  bool operator!=(SearchOptionsKit const & in_kit) const;
38696 
38700  SearchOptionsKit & SetCriteria(Search::Type in_request);
38701 
38705  SearchOptionsKit & SetBehavior(Search::Behavior in_behavior);
38706 
38710  SearchOptionsKit & SetCriteria(SearchTypeArray const & in_requests);
38711 
38716  SearchOptionsKit & SetCriteria(size_t in_count, Search::Type const in_requests []);
38717 
38721  SearchOptionsKit & SetSearchSpace(Search::Space in_search_space);
38722 
38725  SearchOptionsKit & UnsetBehavior();
38726 
38729  SearchOptionsKit & UnsetCriteria();
38730 
38733  SearchOptionsKit & UnsetSearchSpace();
38734 
38737  SearchOptionsKit & UnsetEverything();
38738 
38742  bool ShowBehavior(Search::Behavior & out_behavior) const;
38743 
38747  bool ShowCriteria(SearchTypeArray & out_types) const;
38748 
38752  bool ShowSearchSpace(Search::Space & out_search_space) const;
38753 };
38754 
38758 class HPS_API TreeContext : public Object
38759 {
38760 public:
38763  TreeContext(bool in_create = true);
38764 
38767  TreeContext(TreeContext const & in_that);
38768 
38772  TreeContext(TreeContext && in_that);
38773 
38777  TreeContext & operator=(TreeContext && in_that);
38778 
38780  virtual ~TreeContext();
38781 
38782  HPS::Type ObjectType() const {return HPS::Type::TreeContext;};
38783 
38787  TreeContext & operator=(TreeContext const & in_that);
38788 
38792  bool Equals(TreeContext const & in_that) const;
38793 
38797  bool operator==(TreeContext const & in_that) const;
38798 
38802  bool operator!=(TreeContext const & in_that) const;
38803 
38804 };
38805 
38807 class HPS_API SelectionOptionsKit : public Object
38808 {
38809 public:
38812 
38815  SelectionOptionsKit(SelectionOptionsKit const & in_kit);
38816 
38821 
38825  SelectionOptionsKit & operator=(SelectionOptionsKit && in_that);
38826 
38827  virtual ~SelectionOptionsKit();
38828 
38829  HPS::Type ObjectType() const {return HPS::Type::SelectionOptionsKit;};
38830 
38834  static SelectionOptionsKit GetDefault();
38835 
38838  void Set(SelectionOptionsKit const & in_kit);
38839 
38842  void Show(SelectionOptionsKit & out_kit) const;
38843 
38847  SelectionOptionsKit & operator=(SelectionOptionsKit const & in_kit);
38848 
38851  bool Empty() const;
38852 
38856  bool Equals(SelectionOptionsKit const & in_kit) const;
38857 
38861  bool operator==(SelectionOptionsKit const & in_kit) const;
38862 
38866  bool operator!=(SelectionOptionsKit const & in_kit) const;
38867 
38875  SelectionOptionsKit & SetProximity(float in_proximity);
38876 
38882  SelectionOptionsKit & SetLevel(Selection::Level in_level);
38883 
38888  SelectionOptionsKit & SetInternalLimit(size_t in_limit);
38889 
38898  SelectionOptionsKit & SetRelatedLimit(size_t in_limit);
38899 
38907  SelectionOptionsKit & SetSorting(bool in_sorted);
38908 
38914  SelectionOptionsKit & SetAlgorithm(Selection::Algorithm in_algorithm);
38915 
38921  SelectionOptionsKit & SetGranularity(Selection::Granularity in_granularity);
38922 
38927  SelectionOptionsKit & SetScope(SegmentKey const & in_start_segment);
38928 
38933  SelectionOptionsKit & SetScope(KeyPath const & in_start_path);
38934 
38939  SelectionOptionsKit & SetTreeContext(TreeContext const & in_tree_context);
38940 
38947  SelectionOptionsKit & SetExtentCullingRespected(bool in_state);
38948 
38955  SelectionOptionsKit & SetDeferralExtentCullingRespected(bool in_state);
38956 
38963  SelectionOptionsKit & SetFrustumCullingRespected(bool in_state);
38964 
38971  SelectionOptionsKit & SetVectorCullingRespected(bool in_state);
38972 
38975  SelectionOptionsKit & UnsetProximity();
38976 
38979  SelectionOptionsKit & UnsetLevel();
38980 
38983  SelectionOptionsKit & UnsetInternalLimit();
38984 
38987  SelectionOptionsKit & UnsetRelatedLimit();
38988 
38991  SelectionOptionsKit & UnsetSorting();
38992 
38995  SelectionOptionsKit & UnsetAlgorithm();
38996 
38999  SelectionOptionsKit & UnsetGranularity();
39000 
39003  SelectionOptionsKit & UnsetScope();
39004 
39007  SelectionOptionsKit & UnsetTreeContext();
39008 
39011  SelectionOptionsKit & UnsetExtentCullingRespected();
39012 
39015  SelectionOptionsKit & UnsetDeferralExtentCullingRespected();
39016 
39019  SelectionOptionsKit & UnsetFrustumCullingRespected();
39020 
39023  SelectionOptionsKit & UnsetVectorCullingRespected();
39024 
39025 
39028  SelectionOptionsKit & UnsetEverything();
39029 
39033  bool ShowProximity(float & out_proximity) const;
39034 
39038  bool ShowLevel(Selection::Level & out_level) const;
39039 
39043  bool ShowInternalLimit(size_t & out_limit) const;
39044 
39048  bool ShowRelatedLimit(size_t & out_limit) const;
39049 
39053  bool ShowSorting(bool & out_sorted) const;
39054 
39058  bool ShowAlgorithm(Selection::Algorithm & out_algorithm) const;
39059 
39063  bool ShowGranularity(Selection::Granularity & out_granularity) const;
39064 
39068  bool ShowScope(KeyPath & out_start_path) const;
39069 
39073  bool ShowTreeContext(TreeContext & out_tree_context) const;
39074 
39078  bool ShowExtentCullingRespected(bool & out_state) const;
39079 
39083  bool ShowDeferralExtentCullingRespected(bool & out_state) const;
39084 
39088  bool ShowFrustumCullingRespected(bool & out_state) const;
39089 
39093  bool ShowVectorCullingRespected(bool & out_state) const;
39094 };
39095 
39096 
39097 
39101 class HPS_API SelectionOptionsControl : public Control
39102 {
39103 public:
39106  explicit SelectionOptionsControl(WindowKey const & in_window);
39107 
39111 
39116 
39120  SelectionOptionsControl & operator=(SelectionOptionsControl && in_that);
39121 
39123 
39124  HPS::Type ObjectType() const {return HPS::Type::SelectionOptionsControl;};
39125 
39129  SelectionOptionsControl & operator=(SelectionOptionsControl const & in_that);
39130 
39136  SelectionOptionsControl & SetProximity(float in_proximity);
39137 
39143  SelectionOptionsControl & SetLevel(Selection::Level in_level);
39144 
39151  SelectionOptionsControl & SetInternalLimit(size_t in_limit);
39152 
39161  SelectionOptionsControl & SetRelatedLimit(size_t in_limit);
39162 
39170  SelectionOptionsControl & SetSorting(bool in_sorted);
39171 
39177  SelectionOptionsControl & SetAlgorithm(Selection::Algorithm in_algorithm);
39178 
39184  SelectionOptionsControl & SetGranularity(Selection::Granularity in_granularity);
39185 
39192  SelectionOptionsControl & SetExtentCullingRespected(bool in_state);
39193 
39200  SelectionOptionsControl & SetDeferralExtentCullingRespected(bool in_state);
39201 
39208  SelectionOptionsControl & SetFrustumCullingRespected(bool in_state);
39209 
39216  SelectionOptionsControl & SetVectorCullingRespected(bool in_state);
39217 
39218  // there is no way to unset default values, intentionally
39219 
39223  bool ShowProximity(float & out_proximity) const;
39224 
39228  bool ShowLevel(Selection::Level & out_level) const;
39229 
39233  bool ShowInternalLimit(size_t & out_limit) const;
39234 
39238  bool ShowRelatedLimit(size_t & out_limit) const;
39239 
39243  bool ShowSorting(bool & out_sorted) const;
39244 
39248  bool ShowAlgorithm(Selection::Algorithm & out_algorithm) const;
39249 
39253  bool ShowGranularity(Selection::Granularity & out_granularity) const;
39254 
39258  bool ShowExtentCullingRespected(bool & out_state) const;
39259 
39263  bool ShowDeferralExtentCullingRespected(bool & out_state) const;
39264 
39268  bool ShowFrustumCullingRespected(bool & out_state) const;
39269 
39273  bool ShowVectorCullingRespected(bool & out_state) const;
39274 
39275 private:
39278 };
39279 
39280 
39281 
39283 class HPS_API SelectionItem : public Object
39284 {
39285 public:
39287  SelectionItem();
39288 
39291  SelectionItem(SelectionItem const & in_that);
39292 
39296  SelectionItem(SelectionItem && in_that);
39297 
39301  SelectionItem & operator=(SelectionItem && in_that);
39302 
39303  virtual ~SelectionItem();
39304 
39305  HPS::Type ObjectType() const {return HPS::Type::SelectionItem;};
39306 
39309  void Set(SelectionItem const & in_that);
39310 
39314  SelectionItem & operator=(SelectionItem const & in_that);
39315 
39319  bool Equals(SelectionItem const & in_that) const;
39320 
39324  bool operator==(SelectionItem const & in_that) const;
39325 
39329  bool operator!=(SelectionItem const & in_that) const;
39330 
39334  bool ShowSelectionLevel(Selection::Level & out_level) const;
39335 
39339  bool ShowSelectedItem(Key & out_selection) const;
39340 
39344  bool ShowPath(KeyPath & out_path) const;
39345 
39349  bool ShowFaces(SizeTArray & out_faces) const;
39350 
39354  bool ShowVertices(SizeTArray & out_vertices) const;
39355 
39360  bool ShowEdges(SizeTArray & out_vertices1, SizeTArray & out_vertices2) const;
39361 
39365  bool ShowCharacters(SizeTArray & out_characters) const;
39366 
39370  bool ShowSelectionPosition(WindowPoint & out_location) const;
39371 
39375  bool ShowSelectionPosition(WorldPoint & out_location) const;
39376 
39377 };
39378 
39380 class HPS_API SelectionResultsIterator : public Object
39381 {
39382 public:
39385 
39390 
39395 
39399  SelectionResultsIterator & operator=(SelectionResultsIterator && in_that);
39400 
39402 
39403  HPS::Type ObjectType() const {return HPS::Type::SelectionResultsIterator;}
39404 
39408  SelectionResultsIterator & operator=(SelectionResultsIterator const & in_that);
39409 
39412  void Set(SelectionResultsIterator const & in_that);
39413 
39415  void Next();
39416 
39419  SelectionResultsIterator & operator++();
39420 
39423  SelectionResultsIterator operator++(int in_val);
39424 
39427  bool operator==(SelectionResultsIterator const & in_search_results_iterator);
39428 
39431  bool operator!=(SelectionResultsIterator const & in_search_results_iterator);
39432 
39433 
39436  bool IsValid() const;
39437 
39439  void Reset();
39440 
39443  SelectionItem GetItem() const;
39444 
39447  SelectionItem operator*() const;
39448 
39449 
39450 };
39451 
39455 class HPS_API SelectionResults : public Object
39456 {
39457 public:
39459  SelectionResults();
39460 
39463  SelectionResults(SelectionResults const & in_that);
39464 
39468  SelectionResults(SelectionResults && in_that);
39469 
39473  SelectionResults & operator=(SelectionResults && in_that);
39474 
39475  ~SelectionResults();
39476 
39477  HPS::Type ObjectType() const {return HPS::Type::SelectionResults;}
39478 
39481  void Assign(SelectionResults const & in_that);
39482 
39486  SelectionResults & operator=(SelectionResults const & in_that);
39487 
39491  bool Equals(SelectionResults const & in_that) const;
39492 
39496  bool operator==(SelectionResults const & in_that) const;
39497 
39501  bool operator!=(SelectionResults const & in_that) const;
39502 
39504  virtual void Reset();
39505 
39508  Selection::Level GetSelectionLevel() const;
39509 
39512  size_t GetCount() const;
39513 
39516  SelectionResultsIterator GetIterator() const;
39517 
39523  bool Union(SelectionResults const & in_that);
39524 
39529  bool Intersect(SelectionResults const & in_that);
39530 
39536  bool SymmetricDifference(SelectionResults const & in_that);
39537 
39542  bool Difference(SelectionResults const & in_that);
39543 
39546  void Copy(SelectionResults const & in_that);
39547 };
39548 
39551 class HPS_API SelectionControl : public Object
39552 {
39553 public:
39556  explicit SelectionControl(WindowKey const & in_window);
39557 
39560  SelectionControl(SelectionControl const & in_that);
39561 
39565  SelectionControl(SelectionControl && in_that);
39566 
39570  SelectionControl & operator=(SelectionControl && in_that);
39571 
39572  ~SelectionControl();
39573 
39574  HPS::Type ObjectType() const {return HPS::Type::SelectionControl;};
39575 
39579  SelectionControl & operator=(SelectionControl const & in_that);
39580 
39586  size_t SelectByPoint(Point const & in_location, SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
39587 
39592  size_t SelectByPoint(Point const & in_location, SelectionResults & out_results) const;
39593 
39599  size_t SelectByArea(Rectangle const & in_area, SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
39600 
39605  size_t SelectByArea(Rectangle const & in_area, SelectionResults & out_results) const;
39606 
39612  size_t SelectByPolygon(PointArray const & in_points, SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
39613 
39618  size_t SelectByPolygon(PointArray const & in_points, SelectionResults & out_results) const;
39619 
39626  size_t SelectByPolygon(size_t in_point_count, Point const in_points [], SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
39627 
39633  size_t SelectByPolygon(size_t in_point_count, Point const in_points [], SelectionResults & out_results) const;
39634 
39640  size_t SelectByLine(PointArray const & in_points, SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
39641 
39646  size_t SelectByLine(PointArray const & in_points, SelectionResults & out_results) const;
39647 
39654  size_t SelectByLine(size_t in_point_count, Point const in_points [], SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
39655 
39661  size_t SelectByLine(size_t in_point_count, Point const in_points [], SelectionResults & out_results) const;
39662 
39663 
39664  //Object space selections
39665 
39671  size_t SelectByShell(ShellKit const & in_shell, SelectionOptionsKit const & in_options, SelectionResults & out_results);
39672 
39677  size_t SelectByShell(ShellKit const & in_shell, SelectionResults & out_results);
39678 
39684  size_t SelectByShell(ShellKey const & in_shell, SelectionOptionsKit const & in_options, SelectionResults & out_results);
39685 
39690  size_t SelectByShell(ShellKey const & in_shell, SelectionResults & out_results);
39691 
39692 
39699  size_t SelectByVolume(SimpleCuboid const & in_volume, SelectionOptionsKit const & in_options, SelectionResults & out_results);
39700 
39706  size_t SelectByVolume(SimpleCuboid const & in_volume, SelectionResults & out_results);
39707 
39708 
39715  size_t SelectByRay(Point const & in_start_point, Vector const & in_direction, SelectionOptionsKit const & in_options, SelectionResults & out_results);
39716 
39722  size_t SelectByRay(Point const & in_start_point, Vector const & in_direction, SelectionResults & out_results);
39723 
39724 private:
39726  SelectionControl();
39727 };
39728 
39729 
39730 
39732 class HPS_API HighlightOptionsKit : public Object
39733 {
39734 public:
39737 
39740  HighlightOptionsKit(char const * in_style_name);
39741 
39745  HighlightOptionsKit(char const * in_style_name, char const * in_secondary_style_name);
39746 
39749  HighlightOptionsKit(HighlightOptionsKit const & in_kit);
39750 
39755 
39759  HighlightOptionsKit & operator=(HighlightOptionsKit && in_that);
39760 
39761  virtual ~HighlightOptionsKit();
39762 
39763  HPS::Type ObjectType() const {return HPS::Type::HighlightOptionsKit;};
39764 
39768  static HighlightOptionsKit GetDefault();
39769 
39772  void Set(HighlightOptionsKit const & in_kit);
39773 
39776  void Show(HighlightOptionsKit & out_kit) const;
39777 
39781  HighlightOptionsKit & operator=(HighlightOptionsKit const & in_kit);
39782 
39785  bool Empty() const;
39786 
39790  bool Equals(HighlightOptionsKit const & in_kit) const;
39791 
39795  bool operator==(HighlightOptionsKit const & in_kit) const;
39796 
39800  bool operator!=(HighlightOptionsKit const & in_kit) const;
39801 
39802 
39806  HighlightOptionsKit & SetStyleName(char const * in_style_name);
39807 
39811  HighlightOptionsKit & SetSecondaryStyleName(char const * in_style_name);
39812 
39819  HighlightOptionsKit & SetOverlay(Drawing::Overlay in_overlay);
39820 
39826  HighlightOptionsKit & SetNotification(bool in_state);
39827 
39828 
39831  HighlightOptionsKit & UnsetStyleName();
39832 
39835  HighlightOptionsKit & UnsetSecondaryStyleName();
39836 
39839  HighlightOptionsKit & UnsetOverlay();
39840 
39843  HighlightOptionsKit & UnsetNotification();
39844 
39847  HighlightOptionsKit & UnsetEverything();
39848 
39849 
39853  bool ShowStyleName(UTF8 & out_style_name) const;
39854 
39858  bool ShowSecondaryStyleName(UTF8 & out_style_name) const;
39859 
39863  bool ShowOverlay(Drawing::Overlay & out_overlay) const;
39864 
39868  bool ShowNotification(bool & out_state) const;
39869 };
39870 
39873 class HPS_API HighlightControl : public Control
39874 {
39875 public:
39878  explicit HighlightControl(WindowKey const & in_window);
39879 
39882  HighlightControl(HighlightControl const & in_that);
39883 
39887  HighlightControl(HighlightControl && in_that);
39888 
39892  HighlightControl & operator=(HighlightControl && in_that);
39893 
39894  ~HighlightControl();
39895 
39896  HPS::Type ObjectType() const {return HPS::Type::HighlightControl;};
39897 
39901  HighlightControl & operator=(HighlightControl const & in_that);
39902 
39907  HighlightControl & Highlight(SelectionResults const & in_items, HighlightOptionsKit const & in_options);
39908 
39913  HighlightControl & Highlight(SelectionItem const & in_item, HighlightOptionsKit const & in_options);
39914 
39919  HighlightControl & Highlight(SearchResults const & in_items, HighlightOptionsKit const & in_options);
39920 
39925  HighlightControl & Highlight(KeyPath const & in_item, HighlightOptionsKit const & in_options);
39926 
39931  HighlightControl & Highlight(Key const & in_item, HighlightOptionsKit const & in_options);
39932 
39937  HighlightControl & Unhighlight(SelectionResults const & in_items, HighlightOptionsKit const & in_options = HighlightOptionsKit());
39938 
39943  HighlightControl & Unhighlight(SelectionItem const & in_item, HighlightOptionsKit const & in_options = HighlightOptionsKit());
39944 
39949  HighlightControl & Unhighlight(SearchResults const & in_items, HighlightOptionsKit const & in_options = HighlightOptionsKit());
39950 
39955  HighlightControl & Unhighlight(KeyPath const & in_item, HighlightOptionsKit const & in_options = HighlightOptionsKit());
39956 
39961  HighlightControl & Unhighlight(Key const & in_item, HighlightOptionsKit const & in_options = HighlightOptionsKit());
39962 
39966  HighlightControl & Unhighlight(HighlightOptionsKit const & in_options);
39967 
39970  HighlightControl & UnhighlightEverything();
39971 
39972 private:
39974  HighlightControl();
39975 };
39976 
39978 class HPS_API UpdateOptionsKit : public Object
39979 {
39980 public:
39982  UpdateOptionsKit();
39983 
39986  UpdateOptionsKit(UpdateOptionsKit const & in_kit);
39987 
39991  UpdateOptionsKit(UpdateOptionsKit && in_that);
39992 
39996  UpdateOptionsKit & operator=(UpdateOptionsKit && in_that);
39997 
39998  virtual ~UpdateOptionsKit();
39999 
40000  HPS::Type ObjectType() const {return HPS::Type::UpdateOptionsKit;};
40001 
40005  static UpdateOptionsKit GetDefault();
40006 
40009  void Set(UpdateOptionsKit const & in_kit);
40010 
40013  void Show(UpdateOptionsKit & out_kit) const;
40014 
40018  UpdateOptionsKit & operator=(UpdateOptionsKit const & in_kit);
40019 
40022  bool Empty() const;
40023 
40027  bool Equals(UpdateOptionsKit const & in_kit) const;
40028 
40032  bool operator==(UpdateOptionsKit const & in_kit) const;
40033 
40037  bool operator!=(UpdateOptionsKit const & in_kit) const;
40038 
40042  UpdateOptionsKit & SetUpdateControl(HPS::Window::UpdateControl in_control);
40043 
40047  UpdateOptionsKit & SetTimeLimit(HPS::Time in_time_limit);
40048 
40051  UpdateOptionsKit & UnsetUpdateControl();
40052 
40055  UpdateOptionsKit & UnsetTimeLimit();
40056 
40059  UpdateOptionsKit & UnsetEverything();
40060 
40061 
40065  bool ShowUpdateControl(HPS::Window::UpdateControl & out_control) const;
40066 
40070  bool ShowTimeLimit(HPS::Time & out_time_limit) const;
40071 
40072 };
40073 
40074 
40075 
40081 class HPS_API UpdateOptionsControl : public Control
40082 {
40083 public:
40086  explicit UpdateOptionsControl(WindowKey const & in_window);
40087 
40090  UpdateOptionsControl(UpdateOptionsControl const & in_that);
40091 
40096 
40100  UpdateOptionsControl & operator=(UpdateOptionsControl && in_that);
40101 
40103 
40104  HPS::Type ObjectType() const {return HPS::Type::UpdateOptionsControl;};
40105 
40109  UpdateOptionsControl & operator=(UpdateOptionsControl const & in_that);
40110 
40114  UpdateOptionsControl & SetUpdateControl(HPS::Window::UpdateControl in_control);
40115 
40119  UpdateOptionsControl & SetTimeLimit(HPS::Time in_time_limit);
40120 
40123  UpdateOptionsControl & UnsetUpdateControl();
40124 
40127  UpdateOptionsControl & UnsetTimeLimit();
40128 
40131  UpdateOptionsControl & UnsetEverything();
40132 
40136  bool ShowUpdateControl(HPS::Window::UpdateControl & out_control) const;
40137 
40141  bool ShowTimeLimit(HPS::Time & out_time_limit) const;
40142 
40143 private:
40146 };
40147 
40150 class HPS_API World : public Object
40151 {
40152 public:
40156  World(char const * in_license);
40157 
40159  ~World();
40160 
40161  HPS::Type ObjectType() const {return HPS::Type::World;};
40162 
40167  World & SetMaterialLibraryDirectory(char const * in_directory);
40168 
40173  World & SetFontDirectory(char const * in_directory);
40174 
40180  World & SetFontDirectories(size_t in_count, UTF8 const in_directories[]);
40181 
40186  World & SetFontDirectories(UTF8Array const & in_directories);
40187 
40193  World & SetDriverConfigFile(char const * in_filename);
40194 
40200  World & SetExchangeLibraryDirectory(char const * in_directory);
40201 
40207  World & SetPublishResourceDirectory(char const * in_directory);
40208 
40213  World & SetParasolidSchemaDirectory(char const * in_directory);
40214 
40219  World & SetRealDWGDirectory(char const * in_directory);
40220 
40226  World & SetRealDWGDirectory(char const * in_directory, UTF8Array const & in_object_enabler_directories);
40227 
40233  World & SetParasolidBodyshopDirectory(char const * in_directory);
40234 
40237  World & UnsetMaterialLibraryDirectory();
40238 
40241  World & UnsetFontDirectories();
40242 
40245  World & UnsetDriverConfigFile();
40246 
40249  World & UnsetExchangeLibraryDirectory();
40250 
40253  World & UnsetPublishResourceDirectory();
40254 
40257  World & UnsetParasolidSchemaDirectory();
40258 
40261  World & UnsetRealDWGDirectory();
40262 
40265  World & UnsetParasolidBodyshopDirectory();
40266 
40270  bool ShowLicense(UTF8 & out_license) const;
40271 
40275  bool ShowMaterialLibraryDirectory(UTF8 & out_directory) const;
40276 
40280  bool ShowFontDirectories(UTF8Array & out_directories) const;
40281 
40285  bool ShowDriverConfigFile(UTF8 & out_filename) const;
40286 
40290  bool ShowExchangeLibraryDirectory(UTF8 & out_directory) const;
40291 
40295  bool ShowPublishResourceDirectory(UTF8 & out_directory) const;
40296 
40300  bool ShowParasolidSchemaDirectory(UTF8 & out_directory) const;
40301 
40306  bool ShowRealDWGDirectory(UTF8 & out_directory, UTF8Array & out_object_enabler_directories) const;
40307 
40311  bool ShowParasolidBodyshopDirectory(UTF8 & out_directory) const;
40312 
40313 
40314 private:
40316  World();
40317 
40319  virtual void Reset() {}
40320 };
40321 
40322 
40338 class HPS_API EmergencyHandler
40339 {
40340 public:
40341 
40344 
40345  virtual ~EmergencyHandler();
40346 
40348  intptr_t GetClassID() const;
40349 
40352  virtual EmergencyHandler * Clone() const = 0;
40353 
40357  virtual void Handle(char const * message, HPS::Emergency::Code code) const = 0;
40358 
40359  static void * operator new (size_t in_size){ return Memory::Allocate(in_size); }
40360  static void operator delete (void * in_ptr, size_t in_size) throw () { HPS_UNREFERENCED(in_size); Memory::Free(in_ptr); }
40361 };
40362 
40363 
40366 class HPS_API Database
40367 {
40368 public:
40373  static void Execute(bool in_once=true);
40374 
40377  static Time GetTime();
40378 
40380  static void Sleep(Time milliseconds);
40381 
40406  static void RelinquishMemory();
40407 
40408 
40434  static void ShowMemoryUsage(size_t & out_allocated, size_t & out_used);
40435 
40443  static void Reset();
40444 
40446  static void Synchronize();
40447 
40450  static WindowKeyArray GetWindowKeys();
40451 
40454  static SegmentKeyArray GetRootSegments();
40455 
40458  static PortfolioKeyArray GetPortfolios();
40459 
40464  static PortfolioKey const GetMaterialLibraryPortfolio();
40465 
40471  static ApplicationWindowKey CreateApplicationWindow(WindowHandle in_window_handle, Window::Driver in_driver = Window::Driver::Default3D);
40472 
40477  static ApplicationWindowKey CreateApplicationWindow(WindowHandle in_window_handle, ApplicationWindowOptionsKit const & in_options);
40478 
40482  static StandAloneWindowKey CreateStandAloneWindow(Window::Driver in_driver = Window::Driver::Default3D);
40483 
40487  static StandAloneWindowKey CreateStandAloneWindow(StandAloneWindowOptionsKit const & in_options);
40488 
40495  static OffScreenWindowKey CreateOffScreenWindow(unsigned int in_width, unsigned int in_height, Window::Driver in_driver = Window::Driver::Default3D);
40496 
40502  static OffScreenWindowKey CreateOffScreenWindow(unsigned int in_width, unsigned int in_height, OffScreenWindowOptionsKit const & in_options);
40503 
40509  static OffScreenWindowKey CreateOffScreenWindow(ImageDefinition const & in_destination_image, Window::Driver in_driver = Window::Driver::Default3D);
40510 
40515  static OffScreenWindowKey CreateOffScreenWindow(ImageDefinition const & in_destination_image, OffScreenWindowOptionsKit const & in_options);
40516 
40519  static SegmentKey CreateRootSegment();
40520 
40523  static PortfolioKey CreatePortfolio();
40524 
40527  static EventDispatcher CreateEventDispatcher();
40528 
40532  static EventDispatcher CreateEventDispatcher(char const * in_name);
40533 
40540  static size_t SelectByShell(ShellKit const & in_shell,
40541  SelectionOptionsKit const & in_options,
40542  SelectionResults & out_results);
40543 
40550  static size_t SelectByShell(ShellKey const & in_shell,
40551  SelectionOptionsKit const & in_options,
40552  SelectionResults & out_results);
40553 
40561  static size_t SelectByVolume(SimpleCuboid const & in_volume,
40562  SelectionOptionsKit const & in_options,
40563  SelectionResults & out_results);
40564 
40572  static size_t SelectByRay(Point const & in_start_point, Vector const & in_direction,
40573  SelectionOptionsKit const & in_options,
40574  SelectionResults & out_results);
40575 
40578  static EventDispatcher const & GetEventDispatcher();
40579 
40580 
40584  static bool GetInformationEventFilter(HPS::Info::Code in_code);
40585 
40589  static bool GetWarningEventFilter(HPS::Info::Code in_code);
40590 
40594  static bool GetErrorEventFilter(HPS::Info::Code in_code);
40595 
40600  static bool SetInformationEventFilter(HPS::Info::Code in_code, bool in_filtered);
40601 
40606  static bool SetWarningEventFilter(HPS::Info::Code in_code, bool in_filtered);
40607 
40612  static bool SetErrorEventFilter(HPS::Info::Code in_code, bool in_filtered);
40613 
40614 
40617  static void SetEmergencyHandler(HPS::EmergencyHandler const & in_emergency_handler);
40618 
40620  static void UnsetEmergencyHandler();
40621 
40624  static size_t GetSoftMemoryLimit();
40625 
40629  static size_t SetSoftMemoryLimit(size_t in_limit_bytes);
40630 
40634  static bool IsDriverAvailable(HPS::Window::Driver in_driver);
40635 
40636 private:
40638  Database();
40639 };
40640 
40641 
40645 
40646 
40647 
40649 class HPS_API EventDispatcher : public Object
40650 {
40651 public:
40654  EventDispatcher();
40655 
40658  EventDispatcher(EventDispatcher const & in_that);
40659 
40663  EventDispatcher(EventDispatcher && in_that);
40664 
40668  EventDispatcher & operator=(EventDispatcher && in_that);
40669 
40670  virtual ~EventDispatcher();
40671 
40672  HPS::Type ObjectType() const {return HPS::Type::EventDispatcher;};
40673 
40677  EventDispatcher & operator=(EventDispatcher const & in_that);
40678 
40682  bool Equals(EventDispatcher const & in_that) const;
40683 
40687  bool operator==(EventDispatcher const & in_that) const;
40688 
40692  bool operator!=(EventDispatcher const & in_that) const;
40693 
40698  bool Subscribe(EventHandler const & in_handler, intptr_t in_type) const;
40699 
40704  bool UnSubscribe(EventHandler const & in_handler, intptr_t in_type) const;
40705 
40710  bool UnSubscribe(EventHandler const & in_handler) const;
40711 
40715  bool UnSubscribe(intptr_t in_type) const;
40716 
40720  bool InjectEvent(Event const & in_event) const;
40721 
40726  EventNotifier InjectEventWithNotifier(Event const & in_event) const;
40727 
40730  void Shutdown() const;
40731 
40734  bool IsShutdown() const;
40735 
40736 
40739  void SetName(char const * in_name) const;
40740 
40743  void ShowName(UTF8 & out_name) const;
40744 
40745 private:
40747  virtual void Reset() {}
40748 };
40749 
40750 
40753 class HPS_API EventHandler : public Object
40754 {
40755 public:
40757  EventHandler();
40758 
40761  EventHandler(EventHandler const & in_that);
40762 
40766  EventHandler(EventHandler && in_that);
40767 
40771  EventHandler & operator=(EventHandler && in_that);
40772 
40776  EventHandler & operator=(EventHandler const & in_that);
40777 
40778  virtual ~EventHandler();
40779 
40780  HPS::Type ObjectType() const {return HPS::Type::EventHandler;};
40781 
40786  bool Subscribe(EventDispatcher const & in_dispatcher, intptr_t in_type) const;
40787 
40792  bool UnSubscribe(EventDispatcher const & in_dispatcher, intptr_t in_type) const;
40793 
40797  bool UnSubscribe(EventDispatcher const & in_dispatcher) const;
40798 
40800  void UnSubscribeEverything() const;
40801 
40803  virtual void Reset() { UnSubscribeEverything(); }
40804 
40807  void Shutdown();
40808 
40811  enum class HandleResult
40812  {
40813  Handled,
40814  NotHandled
40815  };
40816 
40821  virtual HandleResult Handle(Event const * in_event) { HPS_UNREFERENCED(in_event); return HandleResult::NotHandled;};
40822 };
40823 
40824 
40825 
40827 class HPS_API TimerTickEvent : public Event
40828 {
40829 public:
40832  {
40833  channel = GetClassID();
40834  consumable = false;
40835  }
40836 
40837 
40840  TimerTickEvent(Event const & in_event) : Event(in_event)
40841  {
40842  if(in_event.GetChannel() != Object::ClassID<TimerTickEvent>())
40843  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
40844  }
40845 
40846  ~TimerTickEvent();
40847 
40850  Event * Clone() const
40851  {
40852  TimerTickEvent * new_event = new TimerTickEvent(*this);
40853  return new_event;
40854  }
40855 
40859  virtual bool Drop(Event const * in_that_event) const
40860  {
40861  HPS_UNREFERENCED(in_that_event);
40862  return true;
40863  }
40864 
40865  virtual intptr_t Freshen() const {
40866  return GetClassID();
40867  }
40868 };
40869 
40871 class HPS_API HighlightEvent : public Event
40872 {
40873 public:
40874  enum class Action
40875  {
40876  None = 0,
40877  Highlight,
40878  Unhighlight,
40879  };
40880 
40883  {
40884  channel = GetClassID();
40885  consumable = false;
40886  action = Action::None;
40887  }
40888 
40889  HighlightEvent(Action in_action, SelectionResults const & in_results = SelectionResults(), HighlightOptionsKit const & in_options = HighlightOptionsKit())
40890  : Event(), action(in_action), results(in_results), options(in_options)
40891  {
40892  channel = GetClassID();
40893  consumable = false;
40894  }
40895 
40898  HighlightEvent(Event const & in_event) : Event(in_event)
40899  {
40900  if (in_event.GetChannel() == Object::ClassID<HighlightEvent>())
40901  {
40902  auto that = static_cast<HighlightEvent const &>(in_event);
40903  action = that.action;
40904  results = that.results;
40905  options = that.options;
40906  }
40907  else
40908  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
40909  }
40910 
40911  ~HighlightEvent();
40912 
40915  Event * Clone() const
40916  {
40917  HighlightEvent * new_event = new HighlightEvent(*this);
40918  return new_event;
40919  }
40920 
40921  Action action;
40922  SelectionResults results;
40923  HighlightOptionsKit options;
40924 };
40925 
40927 class HPS_API InformationEvent : public Event
40928 {
40929 public:
40931  InformationEvent() : Event(), code(HPS::Info::Code::Unknown) { channel = GetClassID(); }
40932 
40935  InformationEvent(char const * in_message) : Event(), message(in_message), code(HPS::Info::Code::Unknown) { channel = GetClassID(); }
40936 
40940  InformationEvent(char const * in_message, HPS::Info::Code in_code) : Event(), message(in_message), code(in_code) { channel = GetClassID(); }
40941 
40944  InformationEvent(Event const & in_event) : Event(in_event)
40945  {
40946  if (in_event.GetChannel() == Object::ClassID<InformationEvent>())
40947  {
40948  InformationEvent const * event = static_cast<InformationEvent const *>(&in_event);
40949  message = event->message;
40950  code = event->code;
40951  }
40952  else
40953  {
40954  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
40955  }
40956  }
40957 
40958  ~InformationEvent();
40959 
40962  Event * Clone() const
40963  {
40964  InformationEvent * new_event = new InformationEvent(*this);
40965  return new_event;
40966  }
40967 
40971  virtual bool Equals(InformationEvent const & in_that) const
40972  {
40973  return message == in_that.message && code == in_that.code;
40974  }
40975 
40979  virtual bool operator== (InformationEvent const & in_that) const
40980  {
40981  return Equals(in_that);
40982  }
40983 
40987  virtual bool operator!= (InformationEvent const & in_that) const
40988  {
40989  return !Equals(in_that);
40990  }
40991 
40994 };
40995 
40996 
40998 class HPS_API WarningEvent : public Event
40999 {
41000 public:
41002  WarningEvent() : Event(), code(HPS::Info::Code::Unknown) { channel = GetClassID(); }
41003 
41006  WarningEvent(char const * in_message) : Event(), message(in_message), code(HPS::Info::Code::Unknown) { channel = GetClassID(); }
41007 
41011  WarningEvent(char const * in_message, HPS::Info::Code in_code) : Event(), message(in_message), code(in_code) { channel = GetClassID(); }
41012 
41015  WarningEvent(Event const & in_event) : Event(in_event)
41016  {
41017  if(in_event.GetChannel() == Object::ClassID<WarningEvent>())
41018  {
41019  WarningEvent const * event = static_cast<WarningEvent const *>(&in_event);
41020  message = event->message;
41021  code = event->code;
41022  }
41023  else
41024  {
41025  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
41026  }
41027  }
41028 
41029  ~WarningEvent();
41030 
41033  Event * Clone() const
41034  {
41035  WarningEvent * new_event = new WarningEvent(*this);
41036  return new_event;
41037  }
41038 
41042  virtual bool Equals(WarningEvent const & in_that) const
41043  {
41044  return message == in_that.message && code == in_that.code;
41045  }
41046 
41050  virtual bool operator== (WarningEvent const & in_that) const
41051  {
41052  return Equals(in_that);
41053  }
41054 
41058  virtual bool operator!= (WarningEvent const & in_that) const
41059  {
41060  return !Equals(in_that);
41061  }
41062 
41065 };
41066 
41067 
41069 class HPS_API ErrorEvent : public Event
41070 {
41071 public:
41073  ErrorEvent() : Event(), code(HPS::Info::Code::Unknown) { channel = GetClassID(); }
41074 
41077  ErrorEvent(char const * in_message) : Event(), message(in_message), code(HPS::Info::Code::Unknown) { channel = GetClassID(); }
41078 
41082  ErrorEvent(char const * in_message, HPS::Info::Code in_code) : Event(), message(in_message), code(in_code) { channel = GetClassID(); }
41083 
41086  ErrorEvent(Event const & in_event) : Event(in_event)
41087  {
41088  if(in_event.GetChannel() == Object::ClassID<ErrorEvent>())
41089  {
41090  ErrorEvent const * event = static_cast<ErrorEvent const *>(&in_event);
41091  message = event->message;
41092  code = event->code;
41093  }
41094  else
41095  {
41096  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
41097  }
41098  }
41099 
41100  ~ErrorEvent();
41101 
41104  Event * Clone() const
41105  {
41106  ErrorEvent * new_event = new ErrorEvent(*this);
41107  return new_event;
41108  }
41109 
41113  virtual bool Equals(ErrorEvent const & in_that) const
41114  {
41115  return message == in_that.message && code == in_that.code;
41116  }
41117 
41121  virtual bool operator== (ErrorEvent const & in_that) const
41122  {
41123  return Equals(in_that);
41124  }
41125 
41129  virtual bool operator!= (ErrorEvent const & in_that) const
41130  {
41131  return !Equals(in_that);
41132  }
41133 
41136 };
41137 
41138 
41140 class HPS_API StandAloneWindowEvent : public Event
41141 {
41142 public:
41143 
41146  enum class Action
41147  {
41148  Unknown,
41149  Close,
41150  FocusIn,
41151  FocusOut,
41152  };
41153 
41155  StandAloneWindowEvent() : Event(), action(Action::Unknown) { channel = GetClassID(); }
41156 
41157 
41160  StandAloneWindowEvent(Action in_action) : Event(), action(in_action) { channel = GetClassID(); }
41161 
41164  StandAloneWindowEvent(Event const & in_event) : Event(in_event)
41165  {
41166  if(in_event.GetChannel() == Object::ClassID<StandAloneWindowEvent>())
41167  {
41168  StandAloneWindowEvent const * event = static_cast<StandAloneWindowEvent const *>(&in_event);
41169  action = event->action;
41170  }
41171  else
41172  {
41173  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
41174  }
41175  }
41176 
41178 
41181  Event * Clone() const
41182  {
41183  StandAloneWindowEvent * new_event = new StandAloneWindowEvent(*this);
41184  return new_event;
41185  }
41186 
41190  virtual bool Equals(StandAloneWindowEvent const & in_that) const
41191  {
41192  return action == in_that.action;
41193  }
41194 
41198  virtual bool operator== (StandAloneWindowEvent const & in_that) const
41199  {
41200  return Equals(in_that);
41201  }
41202 
41206  virtual bool operator!= (StandAloneWindowEvent const & in_that) const
41207  {
41208  return !Equals(in_that);
41209  }
41210 
41212 };
41213 
41215 class HPS_API FocusLostEvent : public Event
41216 {
41217 public:
41220  Event()
41221  { channel = GetClassID(); }
41222 
41223  ~FocusLostEvent();
41224 
41227  Event * Clone() const
41228  {
41229  FocusLostEvent * new_event = new FocusLostEvent(*this);
41230  return new_event;
41231  }
41232 };
41233 
41234 
41236 class HPS_API UpdateCompletedEvent : public Event
41237 {
41238 public:
41240  UpdateCompletedEvent() : Event(), update_time(-1) { channel = GetClassID(); }
41241 
41243  UpdateCompletedEvent(Time in_update_time) : Event(), update_time(in_update_time) { channel = GetClassID(); }
41244 
41247  UpdateCompletedEvent(Event const & in_event) : Event(in_event)
41248  {
41249  if(in_event.GetChannel() == Object::ClassID<UpdateCompletedEvent>())
41250  {
41251  UpdateCompletedEvent const * event = static_cast<UpdateCompletedEvent const *>(&in_event);
41252  update_time = event->update_time;
41253  }
41254  else
41255  {
41256  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
41257  }
41258  }
41259 
41260  virtual ~UpdateCompletedEvent();
41261 
41264  Event * Clone() const
41265  {
41266  UpdateCompletedEvent * new_event = new UpdateCompletedEvent(*this);
41267  return new_event;
41268  }
41269 
41270  Time update_time;
41271 };
41272 
41274 class HPS_API ImportStatusEvent : public Event
41275 {
41276 public:
41279  : Event()
41280  , import_status_message(HPS::UTF8())
41281  { channel = GetClassID(); }
41282 
41283  ImportStatusEvent(char const * in_message)
41284  : Event()
41285  , import_status_message(in_message)
41286  { channel = GetClassID(); }
41287 
41290  ImportStatusEvent(Event const & in_event) : Event(in_event)
41291  {
41292  if (in_event.GetChannel() == Object::ClassID<ImportStatusEvent>())
41293  {
41294  auto event = static_cast<ImportStatusEvent const &>(in_event);
41295  import_status_message = event.import_status_message;
41296  }
41297  else
41298  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
41299  }
41300 
41301  ~ImportStatusEvent();
41302 
41305  Event * Clone() const
41306  {
41307  ImportStatusEvent * new_event = new ImportStatusEvent(*this);
41308  return new_event;
41309  }
41310 
41311  HPS::UTF8 import_status_message;
41312 };
41313 
41315 class HPS_API ModifierKeys
41316 {
41317 public:
41319  ModifierKeys() : modifiers(_key_none) {}
41320 
41324  bool Equals(ModifierKeys const & in_that) const
41325  {
41326  return modifiers == in_that.modifiers;
41327  }
41328 
41332  bool operator== (ModifierKeys const & in_that) const
41333  {
41334  return Equals(in_that);
41335  }
41336 
41340  bool operator!= (ModifierKeys const & in_that) const
41341  {
41342  return !Equals(in_that);
41343  }
41344 
41347  bool None() const { return modifiers == _key_none; }
41348 
41351  bool Shift() const { return (modifiers & _key_shift) != 0; }
41352 
41355  bool Control() const { return (modifiers & _key_control) != 0; }
41356 
41359  bool Alt() const { return (modifiers & _key_alt) != 0; }
41360 
41363  bool Meta() const { return (modifiers & _key_meta) != 0; }
41364 
41365 
41369  bool HasAll(ModifierKeys const & in_keys) const { return (modifiers & in_keys.modifiers) == in_keys.modifiers; }
41370 
41374  bool HasAny(ModifierKeys const & in_keys) const { return (modifiers & in_keys.modifiers) != 0; }
41375 
41376 
41379  void Shift(bool in_state) { if(in_state) modifiers |= _key_shift; else modifiers &= ~(_key_shift); }
41380 
41383  void Control(bool in_state) { if(in_state) modifiers |= _key_control; else modifiers &= ~(_key_control); }
41384 
41387  void Alt(bool in_state) { if(in_state) modifiers |= _key_alt; else modifiers &= ~(_key_alt); }
41388 
41391  void Meta(bool in_state) { if(in_state) modifiers |= _key_meta; else modifiers &= ~(_key_meta); }
41392 
41396  ModifierKeys operator+ (ModifierKeys const & in_modifiers_to_merge)
41397  {
41398  ModifierKeys ret;
41399  ret.modifiers = modifiers | in_modifiers_to_merge.modifiers;
41400  return ret;
41401  }
41402 
41406  ModifierKeys operator- (ModifierKeys const & in_modifiers_to_remove)
41407  {
41408  ModifierKeys ret;
41409  ret.modifiers = modifiers & ~in_modifiers_to_remove.modifiers;
41410  return ret;
41411  }
41412 
41416  ModifierKeys & operator+= (ModifierKeys const & in_modifiers_to_merge) { *this = *this + in_modifiers_to_merge; return *this; }
41417 
41421  ModifierKeys & operator-= (ModifierKeys const & in_modifiers_to_remove) { *this = *this - in_modifiers_to_remove; return *this; }
41422 
41423 
41426  static ModifierKeys KeyShift() { ModifierKeys ret; ret.Shift(true); return ret; }
41427 
41430  static ModifierKeys KeyControl() { ModifierKeys ret; ret.Control(true); return ret; }
41431 
41434  static ModifierKeys KeyAlt() { ModifierKeys ret; ret.Alt(true); return ret; }
41435 
41438  static ModifierKeys KeyMeta() { ModifierKeys ret; ret.Meta(true); return ret; }
41439 
41440 protected:
41441 
41445  {
41446  _key_none = 0x0000,
41447  _key_shift = 0x0001,
41448  _key_control = 0x0002,
41449  _key_alt = 0x0004,
41450  _key_meta = 0x0008,
41451  };
41452 
41453  int modifiers;
41454 };
41455 
41456 
41459 class HPS_API InputEvent : public Event
41460 {
41461 public:
41462 
41464  InputEvent() : Event() { channel = GetClassID(); }
41465 
41468  InputEvent(ModifierKeys const & in_modifiers) : Event(), ModifierKeyState(in_modifiers) { channel = GetClassID(); }
41469 
41470  ~InputEvent();
41471 
41474  Event * Clone() const
41475  {
41476  InputEvent * new_event = new InputEvent(*this);
41477  return new_event;
41478  }
41479 
41483  virtual bool Equals(InputEvent const & in_that) const
41484  {
41485  return ModifierKeyState == in_that.ModifierKeyState;
41486  }
41487 
41491  virtual bool operator== (InputEvent const & in_that) const
41492  {
41493  return Equals(in_that);
41494  }
41495 
41499  virtual bool operator!= (InputEvent const & in_that) const
41500  {
41501  return !Equals(in_that);
41502  }
41503 
41507  {
41508  return ModifierKeyState;
41509  }
41510 
41512 };
41513 
41515 class HPS_API TouchEvent : public InputEvent
41516 {
41517 public:
41520  enum class Action
41521  {
41522  TouchDown,
41523  TouchUp,
41524  Move,
41525  };
41526 
41528  TouchEvent() : InputEvent() { channel = GetClassID(); }
41529 
41534  TouchEvent(Action in_action, ModifierKeys in_modifier = ModifierKeys())
41535  : InputEvent(in_modifier), CurrentAction(in_action) { channel = GetClassID(); }
41536 
41542  TouchEvent(Action in_action, TouchArray const & in_touches, ModifierKeys in_modifier = ModifierKeys())
41543  : InputEvent(in_modifier), CurrentAction(in_action), Touches(in_touches) { channel = GetClassID(); }
41544 
41551  TouchEvent(Action in_action, size_t in_touch_count, Touch const in_touches[], ModifierKeys in_modifier = ModifierKeys())
41552  : InputEvent(in_modifier), CurrentAction(in_action), Touches(in_touches, in_touches + in_touch_count) { channel = GetClassID(); }
41553 
41554 
41557  TouchEvent(Event const & in_event) : InputEvent()
41558  {
41559  if(in_event.GetChannel() == Object::ClassID<TouchEvent>())
41560  {
41561  TouchEvent const * event = static_cast<TouchEvent const *>(&in_event);
41562  channel = GetClassID();
41563  CurrentAction = event->CurrentAction;
41564  Touches = event->Touches;
41565  ModifierKeyState = event->ModifierKeyState;
41566  }
41567  else
41568  throw HPS::InvalidSpecificationException("Invalid Event type to cast from.");
41569  }
41570 
41571  ~TouchEvent();
41572 
41573 
41576  Event * Clone() const
41577  {
41578  TouchEvent * new_event = new TouchEvent(*this);
41579  return new_event;
41580  }
41581 
41585  virtual bool Equals(TouchEvent const & in_that) const
41586  {
41587  return InputEvent::Equals(in_that) && Touches == in_that.Touches && CurrentAction == in_that.CurrentAction;
41588  }
41589 
41593  virtual bool operator== (TouchEvent const & in_that) const
41594  {
41595  return Equals(in_that);
41596  }
41597 
41601  virtual bool operator!= (TouchEvent const & in_that) const
41602  {
41603  return !Equals(in_that);
41604  }
41605 
41609  virtual bool Drop(Event const * in_that_event) const
41610  {
41611  HPS::TouchEvent const * that_touch_event = static_cast<HPS::TouchEvent const *>(in_that_event);
41612 
41613  if (CurrentAction == that_touch_event->CurrentAction && CurrentAction == Action::Move
41614  && Touches.size() == that_touch_event->Touches.size() )
41615  {
41616  TouchArray these_touches = Touches;
41617  TouchArray those_touches = that_touch_event->Touches;
41618 
41619  std::sort(those_touches.begin(), those_touches.end(), sort_predicate);
41620  std::sort(these_touches.begin(), these_touches.end(), sort_predicate);
41621 
41622  for (size_t i = 0 ; i < these_touches.size() ; i++)
41623  {
41624  if (these_touches[i].ID != those_touches[i].ID)
41625  return false;
41626  }
41627  return true;
41628  }
41629 
41630  return false;
41631  }
41632 
41634  HPS::TouchArray Touches;
41635 
41636 private:
41642  static bool sort_predicate(Touch const & in_a, Touch const & in_b)
41643  {
41644  return static_cast<int>(in_a.ID) < static_cast<int>(in_b.ID);
41645  }
41646 };
41647 
41648 
41650 class HPS_API MouseButtons
41651 {
41652 public:
41654  MouseButtons() : buttons(_button_none) {}
41655 
41659  bool Equals(MouseButtons const & in_that) const
41660  {
41661  return buttons == in_that.buttons;
41662  }
41663 
41667  bool operator== (MouseButtons const & in_that) const
41668  {
41669  return Equals(in_that);
41670  }
41671 
41675  bool operator!= (MouseButtons const & in_that) const
41676  {
41677  return !Equals(in_that);
41678  }
41679 
41682  bool None() const { return buttons == _button_none; }
41683 
41686  bool Left() const { return (buttons & _button_left) != 0; }
41687 
41690  bool Right() const { return (buttons & _button_right) != 0; }
41691 
41694  bool Middle() const { return (buttons & _button_middle) != 0; }
41695 
41698  bool X1() const { return (buttons & _button_x1) != 0; }
41699 
41702  bool X2() const { return (buttons & _button_x2) != 0; }
41703 
41704 
41708  bool HasAll(MouseButtons const & in_buttons) const { return (buttons & in_buttons.buttons) == in_buttons.buttons; }
41709 
41713  bool HasAny(MouseButtons const & in_buttons) const { return (buttons & in_buttons.buttons) != 0; }
41714 
41717  void Left(bool in_state) { if(in_state) buttons |= _button_left; else buttons &= ~(_button_left); }
41718 
41721  void Right(bool in_state) { if(in_state) buttons |= _button_right; else buttons &= ~(_button_right); }
41722 
41725  void Middle(bool in_state) { if(in_state) buttons |= _button_middle; else buttons &= ~(_button_middle); }
41726 
41729  void X1(bool in_state) { if(in_state) buttons |= _button_x1; else buttons &= ~(_button_x1); }
41730 
41733  void X2(bool in_state) { if(in_state) buttons |= _button_x2; else buttons &= ~(_button_x2); }
41734 
41738  MouseButtons operator+ (MouseButtons const & in_buttons_to_merge)
41739  {
41740  MouseButtons ret;
41741  ret.buttons = buttons | in_buttons_to_merge.buttons;
41742  return ret;
41743  }
41744 
41748  MouseButtons operator- (MouseButtons const & in_buttons_to_remove)
41749  {
41750  MouseButtons ret;
41751  ret.buttons = buttons & ~in_buttons_to_remove.buttons;
41752  return ret;
41753  }
41754 
41758  MouseButtons & operator+= (MouseButtons const & in_buttons_to_merge) { *this = *this + in_buttons_to_merge; return *this; }
41759 
41763  MouseButtons & operator-= (MouseButtons const & in_buttons_to_remove) { *this = *this - in_buttons_to_remove; return *this; }
41764 
41765 
41768  static MouseButtons ButtonLeft() { MouseButtons ret; ret.Left(true); return ret; }
41769 
41772  static MouseButtons ButtonRight() { MouseButtons ret; ret.Right(true); return ret; }
41773 
41776  static MouseButtons ButtonMiddle() { MouseButtons ret; ret.Middle(true); return ret; }
41777 
41780  static MouseButtons ButtonX1() { MouseButtons ret; ret.X1(true); return ret; }
41781 
41784  static MouseButtons ButtonX2() { MouseButtons ret; ret.X2(true); return ret; }
41785 
41786 protected:
41787 
41790  enum Buttons
41791  {
41792  _button_none = 0x0000,
41793  _button_left = 0x0001,
41794  _button_right = 0x0002,
41795  _button_middle = 0x0004,
41796  _button_x1 = 0x0008,
41797  _button_x2 = 0x0010
41798  };
41799 
41800  int buttons;
41801 };
41802 
41804 class HPS_API MouseEvent : public InputEvent
41805 {
41806 public:
41807 
41810  enum class Action
41811  {
41812  ButtonUp,
41813  ButtonDown,
41814  Move,
41815  Scroll,
41816  Enter,
41817  Leave
41818  };
41819 
41821  MouseEvent() : InputEvent() { channel = GetClassID(); }
41822 
41829  MouseEvent(Action in_action, WindowPoint in_location, MouseButtons in_button = MouseButtons(), ModifierKeys in_modifier = ModifierKeys(), size_t in_click_count = 0)
41830  : InputEvent(in_modifier), CurrentAction(in_action), Location(in_location), CurrentButton(in_button), WheelDelta(0), ClickCount(in_click_count) { channel = GetClassID(); }
41831 
41839  MouseEvent(Action in_action, float in_wheel_delta, WindowPoint in_location = WindowPoint(0,0,0), ModifierKeys in_modifier = ModifierKeys(), size_t in_click_count = 0)
41840  : InputEvent(in_modifier), CurrentAction(in_action), Location(in_location), WheelDelta(in_wheel_delta), ClickCount(in_click_count) { channel = GetClassID(); }
41841 
41844  MouseEvent(Event const & in_event) : InputEvent()
41845  {
41846  if(in_event.GetChannel() == Object::ClassID<MouseEvent>())
41847  {
41848  MouseEvent const * event = static_cast<MouseEvent const *>(&in_event);
41849  channel = GetClassID();
41850  CurrentAction = event->CurrentAction;
41851  Location = event->Location;
41852  CurrentButton = event->CurrentButton;
41853  WheelDelta = event->WheelDelta;
41854  ClickCount = event->ClickCount;
41855  }
41856  else
41857  {
41858  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
41859  }
41860  }
41861 
41862  ~MouseEvent();
41863 
41866  Event * Clone() const
41867  {
41868  MouseEvent * new_event = new MouseEvent(*this);
41869  return new_event;
41870  }
41871 
41875  virtual bool Equals(MouseEvent const & in_that) const
41876  {
41877  return InputEvent::Equals(in_that) && CurrentAction == in_that.CurrentAction
41878  && CurrentButton == in_that.CurrentButton && WheelDelta == in_that.WheelDelta
41879  && Location == in_that.Location && ClickCount == in_that.ClickCount;
41880  }
41881 
41885  virtual bool operator== (MouseEvent const & in_that) const
41886  {
41887  return Equals(in_that);
41888  }
41889 
41893  virtual bool operator!= (MouseEvent const & in_that) const
41894  {
41895  return !Equals(in_that);
41896  }
41897 
41901  virtual bool Drop(Event const * in_that_event) const
41902  {
41903  HPS::MouseEvent const * that_mouse_event = static_cast<HPS::MouseEvent const *>(in_that_event);
41904 
41905  if (CurrentAction == that_mouse_event->CurrentAction &&
41906  (CurrentAction == Action::ButtonDown || CurrentAction == Action::ButtonUp || CurrentAction == Action::Move) &&
41907  CurrentButton == that_mouse_event->CurrentButton)
41908  return true;
41909 
41910  return false;
41911  }
41912 
41913  virtual intptr_t Freshen() const {
41914 
41915  if (CurrentAction == Action::Move)
41916  return GetClassID();
41917 
41918  return 0;
41919  }
41920 
41924  float WheelDelta;
41925  size_t ClickCount;
41926 };
41927 
41928 
41930 class HPS_API KeyboardEvent : public InputEvent
41931 {
41932 public:
41935  enum class Action
41936  {
41937  None,
41938  KeyDown,
41939  KeyUp
41940  };
41941 
41943  KeyboardEvent() : InputEvent(), CurrentAction(Action::None) { channel = GetClassID(); }
41944 
41949  : InputEvent(in_modifiers), CurrentAction(in_action) { channel = GetClassID(); }
41950 
41956  KeyboardEvent(KeyboardEvent::Action in_action, size_t in_keyboardcode_count, HPS::KeyboardCode const in_keyboardcodes[], ModifierKeys in_modifiers = ModifierKeys())
41957  : InputEvent(in_modifiers), CurrentAction(in_action)
41958  {
41959  channel = GetClassID();
41960  KeyboardCodes.assign(in_keyboardcodes, in_keyboardcodes + in_keyboardcode_count);
41961  }
41962 
41967  KeyboardEvent(KeyboardEvent::Action in_action, KeyboardCodeArray const & in_keyboardcodes, ModifierKeys in_modifiers = ModifierKeys())
41968  : InputEvent(in_modifiers), CurrentAction(in_action)
41969  {
41970  channel = GetClassID();
41971  KeyboardCodes = in_keyboardcodes;
41972  }
41973 
41976  KeyboardEvent(Event const & in_event) : InputEvent()
41977  {
41978  if(in_event.GetChannel() == Object::ClassID<KeyboardEvent>())
41979  {
41980  KeyboardEvent const * event = static_cast<KeyboardEvent const *>(&in_event);
41981  channel = GetClassID();
41982  KeyboardCodes = event->KeyboardCodes;
41983  CurrentAction = event->CurrentAction;
41984  }
41985  else
41986  {
41987  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
41988  }
41989  }
41990 
41991  ~KeyboardEvent();
41992 
41995  Event * Clone() const
41996  {
41997  KeyboardEvent * new_event = new KeyboardEvent(*this);
41998  return new_event;
41999  }
42000 
42004  virtual bool Equals(KeyboardEvent const & in_that) const
42005  {
42006  return InputEvent::Equals(in_that) && CurrentAction == in_that.CurrentAction && KeyboardCodes == in_that.KeyboardCodes;
42007  }
42008 
42012  virtual bool operator== (KeyboardEvent const & in_that) const
42013  {
42014  return Equals(in_that);
42015  }
42016 
42020  virtual bool operator!= (KeyboardEvent const & in_that) const
42021  {
42022  return !Equals(in_that);
42023  }
42024 
42028  void SetKeyboardCodes(size_t in_keyboardcode_count, HPS::KeyboardCode const in_keyboardcodes[])
42029  {
42030  KeyboardCodes.assign(in_keyboardcodes, in_keyboardcodes + in_keyboardcode_count);
42031  }
42032 
42035  void SetKeyboardCodes(HPS::KeyboardCodeArray const & in_keyboardcodes)
42036  {
42037  KeyboardCodes = in_keyboardcodes;
42038  }
42039 
42040  HPS::KeyboardCodeArray KeyboardCodes;
42042 };
42043 
42044 
42046 class HPS_API MouseState : public Object
42047 {
42048 public:
42050  MouseState();
42051 
42054  MouseState(MouseState const & in_that);
42055 
42059  MouseState(MouseState && in_that);
42060 
42064  MouseState & operator=(MouseState && in_that);
42065 
42066  ~MouseState();
42067 
42068  HPS::Type ObjectType() const {return HPS::Type::MouseState;};
42069 
42072  void Assign(MouseState const & in_that);
42073 
42077  MouseState & operator=(MouseState const & in_that);
42078 
42082  bool Equals(MouseState const & in_that) const;
42083 
42087  bool operator== (MouseState const & in_that) const;
42088 
42092  bool operator!= (MouseState const & in_that) const;
42093 
42098  bool HasAll(MouseButtons in_mouse_trigger, ModifierKeys in_modifier_trigger) const;
42099 
42106  void Set(KeyArray const & in_path, MouseEvent const & in_event, WindowPoint const & in_point, MouseButtons in_buttons = MouseButtons(), ModifierKeys in_modifiers = ModifierKeys());
42107 
42110  HPS::MouseEvent GetActiveEvent() const;
42111 
42115  HPS::WindowKey GetEventSource() const;
42116 
42120  HPS::KeyArray GetEventPath() const;
42121 
42124  MouseButtons GetButtons() const;
42125 
42128  WindowPoint GetLocation() const;
42129 
42132  ModifierKeys GetModifierKeys() const;
42133 
42136  void SetActiveEvent(MouseEvent const & in_event);
42137 
42140  void SetEventPath(KeyArray const & in_path);
42141 
42144  void SetButtons(MouseButtons in_buttons);
42145 
42148  void SetLocation(WindowPoint const & in_point);
42149 
42152  void SetModifierKeys(ModifierKeys in_modifiers);
42153 };
42154 
42155 
42156 
42158 class HPS_API TouchState : public Object
42159 {
42160 public:
42162  TouchState();
42163 
42166  TouchState(TouchState const & in_that);
42167 
42171  TouchState(TouchState && in_that);
42172 
42176  TouchState & operator=(TouchState && in_that);
42177 
42178  ~TouchState();
42179 
42180  HPS::Type ObjectType() const {return HPS::Type::TouchState;};
42181 
42184  void Assign(TouchState const & in_that);
42185 
42189  TouchState & operator=(TouchState const & in_that);
42190 
42194  bool Equals(TouchState const & in_that) const;
42195 
42199  bool operator== (TouchState const & in_that) const;
42200 
42204  bool operator!= (TouchState const & in_that) const;
42205 
42211  void Set(KeyArray const & in_path, TouchEvent const & in_event, TouchArray const & in_touches, ModifierKeys in_modifiers = ModifierKeys());
42212 
42215  HPS::TouchEvent GetActiveEvent() const;
42216 
42220  HPS::WindowKey GetEventSource() const;
42221 
42225  HPS::KeyArray GetEventPath() const;
42226 
42229  size_t GetTouchCount() const;
42230 
42233  HPS::TouchArray GetTouches() const;
42234 
42237  ModifierKeys GetModifierKeys() const;
42238 
42241  void SetActiveEvent(TouchEvent const & in_event);
42242 
42245  void SetEventPath(KeyArray const & in_path);
42246 
42249  void SetTouches(TouchArray const & in_touches);
42250 
42253  void SetModifierKeys(ModifierKeys in_modifiers);
42254 };
42255 
42256 
42257 
42259 class HPS_API KeyboardState : public Object
42260 {
42261 public:
42263  KeyboardState();
42264 
42267  KeyboardState(KeyboardState const & in_that);
42268 
42272  KeyboardState(KeyboardState && in_that);
42273 
42277  KeyboardState & operator=(KeyboardState && in_that);
42278 
42279  ~KeyboardState();
42280 
42281  HPS::Type ObjectType() const {return HPS::Type::KeyboardState;};
42282 
42285  void Assign(KeyboardState const & in_that);
42286 
42290  KeyboardState & operator=(KeyboardState const & in_that);
42291 
42295  bool Equals(KeyboardState const & in_that) const;
42296 
42300  bool operator== (KeyboardState const & in_that) const;
42301 
42305  bool operator!= (KeyboardState const & in_that) const;
42306 
42312  void Set(KeyArray const & in_path, KeyboardEvent const & in_event, KeyboardCodeArray const & in_keyboard_codes, ModifierKeys in_modifiers = ModifierKeys());
42313 
42316  HPS::KeyboardEvent GetActiveEvent() const;
42317 
42321  HPS::WindowKey GetEventSource() const;
42322 
42326  HPS::KeyArray GetEventPath() const;
42327 
42330  size_t GetKeyboardCodeCount() const;
42331 
42334  HPS::KeyboardCodeArray GetKeyboardCodes() const;
42335 
42339  bool GetKeyState(HPS::KeyboardCode in_key_code) const;
42340 
42343  ModifierKeys GetModifierKeys() const;
42344 
42347  void SetActiveEvent(KeyboardEvent const & in_event);
42348 
42351  void SetEventPath(KeyArray const & in_path);
42352 
42355  void SetKeyboardCodes(KeyboardCodeArray const & in_keyboard_codes);
42356 
42359  void SetModifierKeys(ModifierKeys in_modifiers);
42360 };
42361 
42362 
42366 
42369 class HPS_API IONotifier : public Object
42370 {
42371 public:
42373  IONotifier();
42374 
42377  IONotifier(IONotifier const & in_that);
42378 
42382  IONotifier(IONotifier && in_that);
42383 
42387  IONotifier & operator=(IONotifier && in_that);
42388 
42389  virtual ~IONotifier();
42390 
42391  HPS::Type ObjectType() const {return HPS::Type::IONotifier;};
42392 
42396  IONotifier & operator=(IONotifier const & in_that);
42397 
42400  void Assign(IONotifier const & in_that);
42401 
42403  void Wait();
42404 
42407  IOResult Status() const;
42408 
42412  IOResult Status(float & out_percent_complete) const;
42413 
42417  void Cancel();
42418 };
42419 
42421 class HPS_API Stream
42422 {
42423 public:
42424  class ImportNotifier;
42425  class ImportOptionsKit;
42426 
42428  class HPS_API Toolkit : public Object
42429  {
42430  public:
42432  Toolkit();
42433 
42436  Toolkit(Toolkit const & in_toolkit);
42437 
42441  Toolkit(Toolkit && in_toolkit);
42442 
42446  Toolkit & operator=(Toolkit const & in_toolkit);
42447 
42451  Toolkit & operator=(Toolkit && in_toolkit);
42452 
42453  HPS::Type ObjectType() const { return HPS::Type::StreamToolkit; }
42454 
42456  virtual void Restart();
42457 
42458  ImportNotifier ParseBuffers(ByteArrayArray const & in_hsf_buffers, ImportOptionsKit const & in_options);
42459  };
42460 
42463  static Toolkit CreateToolkit();
42464 
42465 
42466 
42468 
42470  class HPS_API ExportEvent
42471  {
42472  protected:
42473  ExportEvent() {}
42474  public:
42475  virtual ~ExportEvent();
42477  intptr_t GetClassID() const;
42480  HPS::ByteArray non_db_user_data;
42481  };
42482 
42484  class HPS_API ExportEventHandler
42485  {
42486  public:
42487  ExportEventHandler() {}
42488  virtual ~ExportEventHandler();
42492  virtual void Handle(ExportEvent * in_event);
42493  };
42494 
42496 
42498  class HPS_API GeometryExportEvent : public ExportEvent
42499  {
42501  GeometryExportEvent & operator=(GeometryExportEvent const &);
42502  public:
42503  GeometryExportEvent();
42504  virtual ~GeometryExportEvent();
42505  GeometryExportEvent(HPS::Key & in_key);
42506 
42509  };
42510 
42512  class HPS_API SegmentExportEvent : public ExportEvent
42513  {
42515  SegmentExportEvent & operator=(SegmentExportEvent const &);
42516  public:
42517  SegmentExportEvent();
42518  virtual ~SegmentExportEvent();
42519  SegmentExportEvent(HPS::SegmentKey & in_segment_key);
42520 
42523  };
42524 
42526 
42528  class HPS_API ImportEvent
42529  {
42530  protected:
42531  ImportEvent() {}
42532  public:
42533  virtual ~ImportEvent();
42535  intptr_t GetClassID() const;
42536  };
42537 
42542  class HPS_API ImportEventHandler
42543  {
42544  public:
42545  ImportEventHandler() {}
42546  virtual ~ImportEventHandler();
42547 
42553  virtual bool Handle(ImportEvent * in_event);
42554  };
42555 
42557 
42558  class HPS_API AttributeLockImportEvent : public ImportEvent
42559  {
42561  AttributeLockImportEvent & operator=(AttributeLockImportEvent const &);
42562  public:
42563  AttributeLockImportEvent();
42564  virtual ~AttributeLockImportEvent();
42565  AttributeLockImportEvent(HPS::SegmentKey & in_segment_key, HPS::AttributeLockKit & in_attribute_lock_kit);
42566 
42567  HPS::SegmentKey & segment_key;
42568  HPS::AttributeLockKit & attribute_lock_kit;
42569  };
42570 
42571  class HPS_API BoundingImportEvent : public ImportEvent
42572  {
42574  BoundingImportEvent & operator=(BoundingImportEvent const &);
42575  public:
42576  BoundingImportEvent();
42577  virtual ~BoundingImportEvent();
42578  BoundingImportEvent(HPS::SegmentKey & in_segment_key, HPS::BoundingKit & in_bounding_kit);
42579 
42580  HPS::SegmentKey & segment_key;
42581  HPS::BoundingKit & bounding_kit;
42582  };
42583 
42584  class HPS_API CameraImportEvent : public ImportEvent
42585  {
42587  CameraImportEvent & operator=(CameraImportEvent const &);
42588  public:
42589  CameraImportEvent();
42590  virtual ~CameraImportEvent();
42591  CameraImportEvent(HPS::SegmentKey & in_segment_key, HPS::CameraKit & in_camera_kit);
42592 
42593  HPS::SegmentKey & segment_key;
42594  HPS::CameraKit & camera_kit;
42595  };
42596 
42597  class HPS_API CircleImportEvent : public ImportEvent
42598  {
42600  CircleImportEvent & operator=(CircleImportEvent const &);
42601  public:
42602  CircleImportEvent();
42603  virtual ~CircleImportEvent();
42604  CircleImportEvent(HPS::SegmentKey & in_segment_key, HPS::CircleKit & in_circle_kit);
42605 
42606  HPS::SegmentKey & segment_key;
42607  HPS::CircleKit & circle_kit;
42608  };
42609 
42610  class HPS_API CircularArcImportEvent : public ImportEvent
42611  {
42613  CircularArcImportEvent & operator=(CircularArcImportEvent const &);
42614  public:
42615  CircularArcImportEvent();
42616  virtual ~CircularArcImportEvent();
42617  CircularArcImportEvent(HPS::SegmentKey & in_segment_key, HPS::CircularArcKit & in_circular_arc_kit);
42618 
42619  HPS::SegmentKey & segment_key;
42620  HPS::CircularArcKit & circular_arc_kit;
42621  };
42622 
42623  class HPS_API CircularWedgeImportEvent : public ImportEvent
42624  {
42626  CircularWedgeImportEvent & operator=(CircularWedgeImportEvent const &);
42627  public:
42628  CircularWedgeImportEvent();
42629  virtual ~CircularWedgeImportEvent();
42630  CircularWedgeImportEvent(HPS::SegmentKey & in_segment_key, HPS::CircularWedgeKit & in_circular_wedge_kit);
42631 
42632  HPS::SegmentKey & segment_key;
42633  HPS::CircularWedgeKit & circular_wedge_kit;
42634  };
42635 
42637  {
42639  ColorInterpolationImportEvent & operator=(ColorInterpolationImportEvent const &);
42640  public:
42641  ColorInterpolationImportEvent();
42642  virtual ~ColorInterpolationImportEvent();
42643  ColorInterpolationImportEvent(HPS::SegmentKey & in_segment_key, HPS::ColorInterpolationKit & in_color_interpolation_kit);
42644 
42645  HPS::SegmentKey & segment_key;
42646  HPS::ColorInterpolationKit & color_interpolation_kit;
42647  };
42648 
42649  class HPS_API CommentImportEvent : public ImportEvent
42650  {
42652  CommentImportEvent & operator=(CommentImportEvent const &);
42653  public:
42654  CommentImportEvent();
42655  virtual ~CommentImportEvent();
42656  CommentImportEvent(HPS::SegmentKey & in_segment_key, const char* in_comment);
42657 
42658  HPS::SegmentKey & segment_key;
42659  HPS::UTF8 const comment;
42660  };
42661 
42662  class HPS_API ConditionImportEvent : public ImportEvent
42663  {
42665  ConditionImportEvent & operator=(ConditionImportEvent const &);
42666  public:
42667  ConditionImportEvent();
42668  virtual ~ConditionImportEvent();
42669  ConditionImportEvent(HPS::SegmentKey & in_segment_key);
42670 
42671  HPS::SegmentKey & segment_key;
42672  HPS::UTF8Array conditions;
42673  };
42674 
42675  class HPS_API ContourLineImportEvent : public ImportEvent
42676  {
42678  ContourLineImportEvent & operator=(ContourLineImportEvent const &);
42679  public:
42680  ContourLineImportEvent();
42681  virtual ~ContourLineImportEvent();
42682  ContourLineImportEvent(HPS::SegmentKey & in_segment_key, HPS::ContourLineKit & in_contour_line_kit);
42683 
42684  HPS::SegmentKey & segment_key;
42685  HPS::ContourLineKit & contour_line_kit;
42686  };
42687 
42689  {
42691  CuttingSectionImportEvent & operator=(CuttingSectionImportEvent const &);
42692  public:
42693  CuttingSectionImportEvent();
42694  virtual ~CuttingSectionImportEvent();
42695  CuttingSectionImportEvent(HPS::SegmentKey & in_segment_key, HPS::CuttingSectionKit & in_cutting_section_kit);
42696 
42697  HPS::SegmentKey & segment_key;
42698  HPS::CuttingSectionKit & cutting_section_kit;
42699  };
42700 
42702  {
42704  CuttingSectionAttributeImportEvent & operator=(CuttingSectionAttributeImportEvent const &);
42705  public:
42706  CuttingSectionAttributeImportEvent();
42707  virtual ~CuttingSectionAttributeImportEvent();
42708  CuttingSectionAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::CuttingSectionAttributeKit & in_cutting_section_attribute_kit);
42709 
42710  HPS::SegmentKey & segment_key;
42711  HPS::CuttingSectionAttributeKit & cutting_section_attribute_kit;
42712  };
42713 
42715  {
42717  CubeMapDefinitionImportEvent & operator=(CubeMapDefinitionImportEvent const &);
42718  public:
42719  CubeMapDefinitionImportEvent();
42720  virtual ~CubeMapDefinitionImportEvent();
42721  CubeMapDefinitionImportEvent(HPS::PortfolioKey & in_portfolio_key, HPS::UTF8 && in_name,
42722  HPS::ImageDefinition & in_negative_z, HPS::ImageDefinition & in_positive_z,
42723  HPS::ImageDefinition & in_negative_x, HPS::ImageDefinition & in_positive_x,
42724  HPS::ImageDefinition & in_negative_y, HPS::ImageDefinition & in_positive_y,
42725  HPS::TextureOptionsKit & in_texture_kit);
42726 
42727  HPS::PortfolioKey & portfolio_key;
42728  UTF8 name;
42729  HPS::ImageDefinition & negative_z;
42730  HPS::ImageDefinition & positive_z;
42731  HPS::ImageDefinition & negative_x;
42732  HPS::ImageDefinition & positive_x;
42733  HPS::ImageDefinition & negative_y;
42734  HPS::ImageDefinition & positive_y;
42735  HPS::TextureOptionsKit & texture_kit;
42736  };
42737 
42738  class HPS_API CullingImportEvent : public ImportEvent
42739  {
42741  CullingImportEvent & operator=(CullingImportEvent const &);
42742  public:
42743  CullingImportEvent();
42744  virtual ~CullingImportEvent();
42745  CullingImportEvent(HPS::SegmentKey & in_segment_key, HPS::CullingKit & in_culling_kit);
42746 
42747  HPS::SegmentKey & segment_key;
42748  HPS::CullingKit & culling_kit;
42749  };
42750 
42752  {
42754  CurveAttributeImportEvent & operator=(CurveAttributeImportEvent const &);
42755  public:
42756  CurveAttributeImportEvent();
42757  virtual ~CurveAttributeImportEvent();
42758  CurveAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::CurveAttributeKit & in_curve_attribute_kit);
42759 
42760  HPS::SegmentKey & segment_key;
42761  HPS::CurveAttributeKit & curve_attribute_kit;
42762  };
42763 
42765  {
42767  CylinderAttributeImportEvent & operator=(CylinderAttributeImportEvent const &);
42768  public:
42769  CylinderAttributeImportEvent();
42770  virtual ~CylinderAttributeImportEvent();
42771  CylinderAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::CylinderAttributeKit & in_cylinder_attribute_kit);
42772 
42773  HPS::SegmentKey & segment_key;
42774  HPS::CylinderAttributeKit & cylinder_attribute_kit;
42775  };
42776 
42777  class HPS_API CylinderImportEvent : public ImportEvent
42778  {
42780  CylinderImportEvent & operator=(CylinderImportEvent const &);
42781  public:
42782  CylinderImportEvent();
42783  virtual ~CylinderImportEvent();
42784  CylinderImportEvent(HPS::SegmentKey & in_segment_key, HPS::CylinderKit & in_cylinder_kit);
42785 
42786  HPS::SegmentKey & segment_key;
42787  HPS::CylinderKit & cylinder_kit;
42788  };
42789 
42791  {
42793  DistantLightPropertyImportEvent & operator=(DistantLightPropertyImportEvent const &);
42794  public:
42795  DistantLightPropertyImportEvent();
42796  virtual ~DistantLightPropertyImportEvent();
42797  DistantLightPropertyImportEvent(HPS::DistantLightKey & in_distant_light_key, HPS::DistantLightKit & in_distant_light_kit);
42798 
42799  HPS::DistantLightKey & distant_light_key;
42800  HPS::DistantLightKit & distant_light_kit;
42801  };
42802 
42803  class HPS_API DistantLightImportEvent : public ImportEvent
42804  {
42806  DistantLightImportEvent & operator=(DistantLightImportEvent const &);
42807  public:
42808  DistantLightImportEvent();
42809  virtual ~DistantLightImportEvent();
42810  DistantLightImportEvent(HPS::SegmentKey & in_segment_key, HPS::DistantLightKit & in_distantlight_kit);
42811 
42812  HPS::SegmentKey & segment_key;
42813  HPS::DistantLightKit & distant_light_kit;
42814  };
42815 
42817  {
42819  DrawingAttributeImportEvent & operator=(DrawingAttributeImportEvent const &);
42820  public:
42821  DrawingAttributeImportEvent();
42822  virtual ~DrawingAttributeImportEvent();
42823  DrawingAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::DrawingAttributeKit & in_drawing_attribute_kit);
42824 
42825  HPS::SegmentKey & segment_key;
42826  HPS::DrawingAttributeKit & drawing_attribute_kit;
42827  };
42828 
42829  class HPS_API EdgeAttributeImportEvent : public ImportEvent
42830  {
42832  EdgeAttributeImportEvent & operator=(EdgeAttributeImportEvent const &);
42833  public:
42834  EdgeAttributeImportEvent();
42835  virtual ~EdgeAttributeImportEvent();
42836  EdgeAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::EdgeAttributeKit & in_edge_attribute_kit);
42837 
42838  HPS::SegmentKey & segment_key;
42839  HPS::EdgeAttributeKit & edge_attribute_kit;
42840  };
42841 
42842  class HPS_API EllipseImportEvent : public ImportEvent
42843  {
42845  EllipseImportEvent & operator=(EllipseImportEvent const &);
42846  public:
42847  EllipseImportEvent();
42848  virtual ~EllipseImportEvent();
42849  EllipseImportEvent(HPS::SegmentKey & in_segment_key, HPS::EllipseKit & in_ellipse_kit);
42850 
42851  HPS::SegmentKey & segment_key;
42852  HPS::EllipseKit & ellipse_kit;
42853  };
42854 
42855  class HPS_API EllipticalArcImportEvent : public ImportEvent
42856  {
42858  EllipticalArcImportEvent & operator=(EllipticalArcImportEvent const &);
42859  public:
42860  EllipticalArcImportEvent();
42861  virtual ~EllipticalArcImportEvent();
42862  EllipticalArcImportEvent(HPS::SegmentKey & in_segment_key, HPS::EllipticalArcKit & in_elliptical_arc_kit);
42863 
42864  HPS::SegmentKey & segment_key;
42865  HPS::EllipticalArcKit & elliptical_arc_kit;
42866  };
42867 
42869  {
42871  GlyphDefinitionImportEvent & operator=(GlyphDefinitionImportEvent const &);
42872  public:
42873  GlyphDefinitionImportEvent();
42874  virtual ~GlyphDefinitionImportEvent();
42875  GlyphDefinitionImportEvent(HPS::PortfolioKey & in_portfolio_key, HPS::UTF8 && in_name, HPS::GlyphKit & in_glyph_kit);
42876 
42877  HPS::PortfolioKey & portfolio_key;
42878  UTF8 name;
42879  HPS::GlyphKit & glyph_kit;
42880  };
42881 
42882  class HPS_API GridImportEvent : public ImportEvent
42883  {
42885  GridImportEvent & operator=(GridImportEvent const &);
42886  public:
42887  GridImportEvent();
42888  virtual ~GridImportEvent();
42889  GridImportEvent(HPS::SegmentKey & in_segment_key, HPS::GridKit & in_grid_kit);
42890 
42891  HPS::SegmentKey & segment_key;
42892  HPS::GridKit & grid_kit;
42893  };
42894 
42896  {
42898  HiddenLineAttributeImportEvent & operator=(HiddenLineAttributeImportEvent const &);
42899  public:
42900  HiddenLineAttributeImportEvent();
42901  virtual ~HiddenLineAttributeImportEvent();
42902  HiddenLineAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::HiddenLineAttributeKit & in_hidden_attribute_kit);
42903 
42904  HPS::SegmentKey & segment_key;
42905  HPS::HiddenLineAttributeKit & hidden_line_attribute_kit;
42906  };
42907 
42909  {
42911  ImageDefinitionImportEvent & operator=(ImageDefinitionImportEvent const &);
42912  public:
42913  ImageDefinitionImportEvent();
42914  virtual ~ImageDefinitionImportEvent();
42915  ImageDefinitionImportEvent(HPS::PortfolioKey & in_portfolio_key, HPS::UTF8 && in_name, HPS::ImageKit & in_image_kit);
42916 
42917  HPS::PortfolioKey & portfolio_key;
42918  UTF8 name;
42919  HPS::ImageKit & image_kit;
42920  };
42921 
42923  {
42925  IncludeSegmentImportEvent & operator=(IncludeSegmentImportEvent const &);
42926  public:
42927  IncludeSegmentImportEvent();
42928  virtual ~IncludeSegmentImportEvent();
42929  IncludeSegmentImportEvent(HPS::SegmentKey & in_segment_key, HPS::SegmentKey & in_reference_segment_key, HPS::Condition & in_condition, HPS::AttributeLockTypeArray && in_filter_types);
42930 
42931  HPS::SegmentKey & segment_key;
42932  HPS::SegmentKey & reference_segment_key;
42933  HPS::Condition & condition;
42934  HPS::AttributeLockTypeArray filter_types;
42935  };
42936 
42937  class HPS_API InfiniteLineImportEvent : public ImportEvent
42938  {
42940  InfiniteLineImportEvent & operator=(InfiniteLineImportEvent const &);
42941  public:
42942  InfiniteLineImportEvent();
42943  virtual ~InfiniteLineImportEvent();
42944  InfiniteLineImportEvent(HPS::SegmentKey & in_segment_key, HPS::InfiniteLineKit & in_infinite_line_kit);
42945 
42946  HPS::SegmentKey & segment_key;
42947  HPS::InfiniteLineKit & infinite_line_kit;
42948  };
42949 
42951  {
42953  LightingAttributeImportEvent & operator=(LightingAttributeImportEvent const &);
42954  public:
42955  LightingAttributeImportEvent();
42956  virtual ~LightingAttributeImportEvent();
42957  LightingAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::LightingAttributeKit & in_lighting_attribute_kit);
42958 
42959  HPS::SegmentKey & segment_key;
42960  HPS::LightingAttributeKit & lighting_attribute_kit;
42961  };
42962 
42963  class HPS_API LineAttributeImportEvent : public ImportEvent
42964  {
42966  LineAttributeImportEvent & operator=(LineAttributeImportEvent const &);
42967  public:
42968  LineAttributeImportEvent();
42969  virtual ~LineAttributeImportEvent();
42970  LineAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::LineAttributeKit & in_line_attribute_kit);
42971 
42972  HPS::SegmentKey & segment_key;
42973  HPS::LineAttributeKit & line_attribute_kit;
42974  };
42975 
42976  class HPS_API LineImportEvent : public ImportEvent
42977  {
42979  LineImportEvent & operator=(LineImportEvent const &);
42980  public:
42981  LineImportEvent();
42982  virtual ~LineImportEvent();
42983  LineImportEvent(HPS::SegmentKey & in_segment_key, HPS::LineKit & in_line_kit);
42984 
42985  HPS::SegmentKey & segment_key;
42986  HPS::LineKit & line_kit;
42987  };
42988 
42990  {
42992  LinePatternDefinitionImportEvent & operator=(LinePatternDefinitionImportEvent const &);
42993  public:
42994  LinePatternDefinitionImportEvent();
42995  virtual ~LinePatternDefinitionImportEvent();
42996  LinePatternDefinitionImportEvent(HPS::PortfolioKey & in_portfolio_key, HPS::UTF8 && in_name, HPS::LinePatternKit & in_line_pattern_kit);
42997 
42998  HPS::PortfolioKey & portfolio_key;
42999  UTF8 name;
43000  HPS::LinePatternKit & line_pattern_kit;
43001  };
43002 
43003  class HPS_API MarkerImportEvent : public ImportEvent
43004  {
43006  MarkerImportEvent & operator=(MarkerImportEvent const &);
43007  public:
43008  MarkerImportEvent();
43009  virtual ~MarkerImportEvent();
43010  MarkerImportEvent(HPS::SegmentKey & in_segment_key, HPS::MarkerKit & in_marker_kit);
43011 
43012  HPS::SegmentKey & segment_key;
43013  HPS::MarkerKit & marker_kit;
43014  };
43015 
43017  {
43019  MarkerAttributeImportEvent & operator=(MarkerAttributeImportEvent const &);
43020  public:
43021  MarkerAttributeImportEvent();
43022  virtual ~MarkerAttributeImportEvent();
43023  MarkerAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::MarkerAttributeKit & in_marker_attribute_kit);
43024 
43025  HPS::SegmentKey & segment_key;
43026  HPS::MarkerAttributeKit & marker_attribute_kit;
43027  };
43028 
43029  class HPS_API MaterialImportEvent : public ImportEvent
43030  {
43032  MaterialImportEvent & operator=(MaterialImportEvent const &);
43033  public:
43034  MaterialImportEvent();
43035  virtual ~MaterialImportEvent();
43036  MaterialImportEvent(HPS::Key & in_key, HPS::MaterialMappingKit & in_material_mapping_kit);
43037 
43038  HPS::Key & key;
43039  HPS::MaterialMappingKit & material_mapping_kit;
43040  };
43041 
43043  {
43045  MaterialPaletteDefinitionImportEvent & operator=(MaterialPaletteDefinitionImportEvent const &);
43046  public:
43047  MaterialPaletteDefinitionImportEvent();
43048  virtual ~MaterialPaletteDefinitionImportEvent();
43049  MaterialPaletteDefinitionImportEvent(HPS::PortfolioKey & in_portfolio_key, HPS::UTF8 && in_name, HPS::MaterialKitArray & in_material_mapping_kit_array);
43050 
43051  HPS::PortfolioKey & portfolio_key;
43052  HPS::UTF8 name;
43053  HPS::MaterialKitArray & material_mapping_kit_array;
43054  };
43055 
43057  {
43059  MaterialPaletteImportEvent & operator=(MaterialPaletteImportEvent const &);
43060  public:
43061  MaterialPaletteImportEvent();
43062  virtual ~MaterialPaletteImportEvent();
43063  MaterialPaletteImportEvent(HPS::SegmentKey & in_segment_key, HPS::UTF8 && in_name);
43064 
43065  HPS::SegmentKey & segment_key;
43066  HPS::UTF8 name;
43067  };
43068 
43069  class HPS_API MatrixImportEvent : public ImportEvent
43070  {
43072  MatrixImportEvent & operator=(MatrixImportEvent const &);
43073  public:
43074  MatrixImportEvent();
43075  virtual ~MatrixImportEvent();
43076  MatrixImportEvent(HPS::Key & in_key, HPS::MatrixKit & in_matrix_kit);
43077 
43078  HPS::Key & key;
43079  HPS::MatrixKit & matrix_kit;
43080  };
43081 
43082  class HPS_API MeshImportEvent : public ImportEvent
43083  {
43085  MeshImportEvent & operator=(MeshImportEvent const &);
43086  public:
43087  MeshImportEvent();
43088  virtual ~MeshImportEvent();
43089  MeshImportEvent(HPS::SegmentKey & in_segment_key, HPS::MeshKit & in_mesh_kit);
43090 
43091  HPS::SegmentKey & segment_key;
43092  HPS::MeshKit & mesh_kit;
43093  };
43094 
43095  class HPS_API MeshInstanceImportEvent : public ImportEvent
43096  {
43098  MeshInstanceImportEvent & operator=(MeshInstanceImportEvent const &);
43099  public:
43100  MeshInstanceImportEvent();
43101  virtual ~MeshInstanceImportEvent();
43102  MeshInstanceImportEvent(HPS::SegmentKey & in_segment_key, HPS::MeshKit & in_mesh_kit, HPS::MatrixKit & in_modelling_matrix);
43103 
43104  HPS::SegmentKey & segment_key;
43105  HPS::MeshKit & mesh_kit;
43106  HPS::MatrixKit & modelling_matrix;
43107  };
43108 
43110  {
43112  NamedStyleDefinitionImportEvent & operator=(NamedStyleDefinitionImportEvent const &);
43113  public:
43114  NamedStyleDefinitionImportEvent();
43115  virtual ~NamedStyleDefinitionImportEvent();
43116  NamedStyleDefinitionImportEvent(HPS::PortfolioKey & in_portfolio_key, HPS::UTF8 && in_name, HPS::SegmentKey & in_style_key);
43117 
43118  HPS::PortfolioKey & portfolio_key;
43119  HPS::UTF8 name;
43120  HPS::SegmentKey & style_key;
43121  };
43122 
43123  class HPS_API NamedStyleImportEvent : public ImportEvent
43124  {
43126  NamedStyleImportEvent & operator=(NamedStyleImportEvent const &);
43127  public:
43128  NamedStyleImportEvent();
43129  virtual ~NamedStyleImportEvent();
43130  NamedStyleImportEvent(HPS::SegmentKey & in_segment_key, HPS::UTF8 && in_name, HPS::Condition & in_condition, HPS::AttributeLockTypeArray && in_filter_types);
43131 
43132  HPS::SegmentKey & segment_key;
43133  HPS::UTF8 name;
43134  HPS::Condition & condition;
43135  HPS::AttributeLockTypeArray filter_types;
43136  };
43137 
43138  class HPS_API NURBSCurveImportEvent : public ImportEvent
43139  {
43141  NURBSCurveImportEvent & operator=(NURBSCurveImportEvent const &);
43142  public:
43143  NURBSCurveImportEvent();
43144  virtual ~NURBSCurveImportEvent();
43145  NURBSCurveImportEvent(HPS::SegmentKey & in_segment_key, HPS::NURBSCurveKit & in_nurbs_curve_kit);
43146 
43147  HPS::SegmentKey & segment_key;
43148  HPS::NURBSCurveKit & nurbs_curve_kit;
43149  };
43150 
43151  class HPS_API NURBSSurfaceImportEvent : public ImportEvent
43152  {
43154  NURBSSurfaceImportEvent & operator=(NURBSSurfaceImportEvent const &);
43155  public:
43156  NURBSSurfaceImportEvent();
43157  virtual ~NURBSSurfaceImportEvent();
43158  NURBSSurfaceImportEvent(HPS::SegmentKey & in_segment_key, HPS::NURBSSurfaceKit & in_nurbs_surface_kit);
43159 
43160  HPS::SegmentKey & segment_key;
43161  HPS::NURBSSurfaceKit & nurbs_surface_kit;
43162  };
43163 
43165  {
43167  NURBSSurfaceAttributeImportEvent & operator=(NURBSSurfaceAttributeImportEvent const &);
43168  public:
43169  NURBSSurfaceAttributeImportEvent();
43170  virtual ~NURBSSurfaceAttributeImportEvent();
43171  NURBSSurfaceAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::NURBSSurfaceAttributeKit & in_nurbs_surface_attribute_kit);
43172 
43173  HPS::SegmentKey & segment_key;
43174  HPS::NURBSSurfaceAttributeKit & nurbs_surface_attribute_kit;
43175  };
43176 
43177  class HPS_API PerformanceImportEvent : public ImportEvent
43178  {
43180  PerformanceImportEvent & operator=(PerformanceImportEvent const &);
43181  public:
43182  PerformanceImportEvent();
43183  virtual ~PerformanceImportEvent();
43184  PerformanceImportEvent(HPS::SegmentKey & in_segment_key, HPS::PerformanceKit & in_performance_kit);
43185 
43186  HPS::SegmentKey & segment_key;
43187  HPS::PerformanceKit & performance_kit;
43188  };
43189 
43190  class HPS_API PolygonImportEvent : public ImportEvent
43191  {
43193  PolygonImportEvent & operator=(PolygonImportEvent const &);
43194  public:
43195  PolygonImportEvent();
43196  virtual ~PolygonImportEvent();
43197  PolygonImportEvent(HPS::SegmentKey & in_segment_key, HPS::PolygonKit & in_polygon_kit);
43198 
43199  HPS::SegmentKey & segment_key;
43200  HPS::PolygonKit & polygon_kit;
43201  };
43202 
43203  class HPS_API PriorityImportEvent : public ImportEvent
43204  {
43206  PriorityImportEvent & operator=(PriorityImportEvent const &);
43207  public:
43208  PriorityImportEvent();
43209  virtual ~PriorityImportEvent();
43210  PriorityImportEvent(HPS::Key & in_key, int in_priority);
43211 
43212  HPS::Key & key;
43213  int priority;
43214  };
43215 
43217  {
43219  ReferenceGeometryImportEvent & operator=(ReferenceGeometryImportEvent const &);
43220  public:
43221  ReferenceGeometryImportEvent();
43222  virtual ~ReferenceGeometryImportEvent();
43223  ReferenceGeometryImportEvent(HPS::SegmentKey & in_segment_key, HPS::Key & in_reference_geometry_key, HPS::Condition & in_condition);
43224 
43225  HPS::SegmentKey & segment_key;
43226  HPS::Key & reference_geometry_key;
43227  HPS::Condition & condition;
43228  };
43229 
43230  class HPS_API SegmentImportEvent : public ImportEvent
43231  {
43233  SegmentImportEvent & operator=(SegmentImportEvent const &);
43234  public:
43235  SegmentImportEvent();
43236  virtual ~SegmentImportEvent();
43237  SegmentImportEvent(HPS::SegmentKey & in_segment_key, HPS::UTF8 && in_name);
43238 
43239  HPS::SegmentKey & segment_key;
43240  HPS::UTF8 name;
43241  };
43242 
43243  class HPS_API SelectabilityImportEvent : public ImportEvent
43244  {
43246  SelectabilityImportEvent & operator=(SelectabilityImportEvent const &);
43247  public:
43248  SelectabilityImportEvent();
43249  virtual ~SelectabilityImportEvent();
43250  SelectabilityImportEvent(HPS::SegmentKey & in_segment_key, HPS::SelectabilityKit & in_selectability_kit);
43251 
43252  HPS::SegmentKey & segment_key;
43253  HPS::SelectabilityKit & selectability_kit;
43254  };
43255 
43257  {
43259  ShaderDefinitionImportEvent & operator=(ShaderDefinitionImportEvent const &);
43260  public:
43261  ShaderDefinitionImportEvent();
43262  virtual ~ShaderDefinitionImportEvent();
43263  ShaderDefinitionImportEvent(HPS::PortfolioKey & in_portfolio_key, HPS::UTF8 && in_name, HPS::ShaderKit & in_shader_kit);
43264 
43265  HPS::PortfolioKey & portfolio_key;
43266  UTF8 name;
43267  HPS::ShaderKit & shader_kit;
43268  };
43269 
43270  class HPS_API ShellImportEvent : public ImportEvent
43271  {
43273  ShellImportEvent & operator=(ShellImportEvent const &);
43274  public:
43275  ShellImportEvent();
43276  virtual ~ShellImportEvent();
43277  ShellImportEvent(HPS::SegmentKey & in_segment_key, HPS::ShellKit & in_shell_kit);
43278 
43279  HPS::SegmentKey & segment_key;
43280  HPS::ShellKit & shell_kit;
43281  };
43282 
43283  class HPS_API ShellInstanceImportEvent : public ImportEvent
43284  {
43286  ShellInstanceImportEvent & operator=(ShellInstanceImportEvent const &);
43287  public:
43288  ShellInstanceImportEvent();
43289  virtual ~ShellInstanceImportEvent();
43290  ShellInstanceImportEvent(HPS::SegmentKey & in_segment_key, HPS::ShellKit & in_shell_kit, HPS::MatrixKit & in_modelling_matrix);
43291 
43292  HPS::SegmentKey & segment_key;
43293  HPS::ShellKit & shell_kit;
43294  HPS::MatrixKit & modelling_matrix;
43295  };
43296 
43297  class HPS_API SphereImportEvent : public ImportEvent
43298  {
43300  SphereImportEvent & operator=(SphereImportEvent const &);
43301  public:
43302  SphereImportEvent();
43303  virtual ~SphereImportEvent();
43304  SphereImportEvent(HPS::SegmentKey & in_segment_key, HPS::SphereKit & in_sphere_kit);
43305 
43306  HPS::SegmentKey & segment_key;
43307  HPS::SphereKit & sphere_kit;
43308  };
43309 
43311  {
43313  SphereAttributeImportEvent & operator=(SphereAttributeImportEvent const &);
43314  public:
43315  SphereAttributeImportEvent();
43316  virtual ~SphereAttributeImportEvent();
43317  SphereAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::SphereAttributeKit & in_sphere_attribute_kit);
43318 
43319  HPS::SegmentKey & segment_key;
43320  HPS::SphereAttributeKit & sphere_attribute_kit;
43321  };
43322 
43323  class HPS_API SpotlightImportEvent : public ImportEvent
43324  {
43326  SpotlightImportEvent & operator=(SpotlightImportEvent const &);
43327  public:
43328  SpotlightImportEvent();
43329  virtual ~SpotlightImportEvent();
43330  SpotlightImportEvent(HPS::SegmentKey & in_segment_key, HPS::SpotlightKit & in_spotlight_kit);
43331 
43332  HPS::SegmentKey & segment_key;
43333  HPS::SpotlightKit & spotlight_kit;
43334  };
43335 
43336  class HPS_API StyleSegmentImportEvent : public ImportEvent
43337  {
43339  StyleSegmentImportEvent & operator=(StyleSegmentImportEvent const &);
43340  public:
43341  StyleSegmentImportEvent();
43342  virtual ~StyleSegmentImportEvent();
43343  StyleSegmentImportEvent(HPS::SegmentKey & in_segment_key, HPS::SegmentKey & in_style_segment_key, HPS::Condition & in_condition, HPS::AttributeLockTypeArray && in_filter_types);
43344 
43345  HPS::SegmentKey & segment_key;
43346  HPS::SegmentKey & style_segment_key;
43347  HPS::Condition & condition;
43348  HPS::AttributeLockTypeArray filter_types;
43349  };
43350 
43351  class HPS_API TextImportEvent : public ImportEvent
43352  {
43354  TextImportEvent & operator=(TextImportEvent const &);
43355  public:
43356  TextImportEvent();
43357  virtual ~TextImportEvent();
43358  TextImportEvent(HPS::SegmentKey & in_segment_key, HPS::TextKit & in_text_kit);
43359 
43360  HPS::SegmentKey & segment_key;
43361  HPS::TextKit & text_kit;
43362  };
43363 
43364  class HPS_API TextAttributeImportEvent : public ImportEvent
43365  {
43367  TextAttributeImportEvent & operator=(TextAttributeImportEvent const &);
43368  public:
43369  TextAttributeImportEvent();
43370  virtual ~TextAttributeImportEvent();
43371  TextAttributeImportEvent(HPS::TextKey & in_text_key, HPS::TextAttributeKit & in_text_attribute_kit);
43372  TextAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::TextAttributeKit & in_text_attribute_kit);
43373 
43374  HPS::Key & key;
43375  HPS::TextAttributeKit & text_attribute_kit;
43376  };
43377 
43379  {
43381  TextureDefinitionImportEvent & operator=(TextureDefinitionImportEvent const &);
43382  public:
43383  TextureDefinitionImportEvent();
43384  virtual ~TextureDefinitionImportEvent();
43385  TextureDefinitionImportEvent(HPS::PortfolioKey & in_portfolio_key, HPS::UTF8 && in_name,
43386  HPS::ImageDefinition & in_source_definition, HPS::TextureOptionsKit & in_texture_kit);
43387 
43388  HPS::PortfolioKey & portfolio_key;
43389  UTF8 name;
43390  HPS::ImageDefinition & source_definition;
43391  HPS::TextureOptionsKit & texture_kit;
43392  };
43393 
43394  class HPS_API TransformMaskImportEvent : public ImportEvent
43395  {
43397  TransformMaskImportEvent & operator=(TransformMaskImportEvent const &);
43398  public:
43399  TransformMaskImportEvent();
43400  virtual ~TransformMaskImportEvent();
43401  TransformMaskImportEvent(HPS::SegmentKey & in_segment_key, HPS::TransformMaskKit & in_transform_mask_kit);
43402 
43403  HPS::SegmentKey & segment_key;
43404  HPS::TransformMaskKit & transform_mask_kit;
43405  };
43406 
43407  class HPS_API TransparencyImportEvent : public ImportEvent
43408  {
43410  TransparencyImportEvent & operator=(TransparencyImportEvent const &);
43411  public:
43412  TransparencyImportEvent();
43413  virtual ~TransparencyImportEvent();
43414  TransparencyImportEvent(HPS::SegmentKey & in_segment_key, HPS::TransparencyKit & in_transparency_kit);
43415 
43416  HPS::SegmentKey & segment_key;
43417  HPS::TransparencyKit & transparency_kit;
43418  };
43419 
43420  class HPS_API SubwindowImportEvent : public ImportEvent
43421  {
43423  SubwindowImportEvent & operator=(SubwindowImportEvent const &);
43424  public:
43425  SubwindowImportEvent();
43426  virtual ~SubwindowImportEvent();
43427  SubwindowImportEvent(HPS::SegmentKey & in_segment_key, HPS::SubwindowKit & in_subwindow_kit);
43428 
43429  HPS::SegmentKey & segment_key;
43430  HPS::SubwindowKit & subwindow_kit;
43431  };
43432 
43434  class HPS_API NonDBUserDataImportEvent : public ImportEvent
43435  {
43437  NonDBUserDataImportEvent & operator=(NonDBUserDataImportEvent const &);
43438  public:
43439  NonDBUserDataImportEvent() {}
43440  virtual ~NonDBUserDataImportEvent();
43441  NonDBUserDataImportEvent(size_t in_count, HPS::byte const in_data[]);
43442 
43444  HPS::ByteArray user_data;
43445  };
43446 
43448  class HPS_API UserDataImportEvent : public ImportEvent
43449  {
43451  UserDataImportEvent & operator=(UserDataImportEvent const &);
43452  public:
43453  virtual ~UserDataImportEvent();
43454  UserDataImportEvent();
43455  UserDataImportEvent(HPS::Key & in_key, intptr_t in_index, size_t in_count, HPS::byte const in_data[]);
43456 
43457  HPS::Key key;
43458  intptr_t index;
43459 
43461  HPS::ByteArray user_data;
43462  };
43463 
43464  class HPS_API VisibilityImportEvent : public ImportEvent
43465  {
43467  VisibilityImportEvent & operator=(VisibilityImportEvent const &);
43468  public:
43469  VisibilityImportEvent();
43470  virtual ~VisibilityImportEvent();
43471  VisibilityImportEvent(HPS::SegmentKey & in_segment_key, HPS::VisibilityKit & in_visibility_kit);
43472 
43473  HPS::SegmentKey & segment_key;
43474  HPS::VisibilityKit & visibility_kit;
43475  };
43476 
43477  class HPS_API VisualEffectsImportEvent : public ImportEvent
43478  {
43480  VisualEffectsImportEvent & operator=(VisualEffectsImportEvent const &);
43481  public:
43482  VisualEffectsImportEvent();
43483  virtual ~VisualEffectsImportEvent();
43484  VisualEffectsImportEvent(HPS::SegmentKey & in_segment_key, HPS::VisualEffectsKit & in_visual_effects_kit);
43485 
43486  HPS::SegmentKey & segment_key;
43487  HPS::VisualEffectsKit & visual_effects_kit;
43488  };
43489 
43491 
43492 
43494  class HPS_API ImportOptionsKit : public Object
43495  {
43496  public:
43498  ImportOptionsKit();
43499 
43502  ImportOptionsKit(ImportOptionsKit const & in_kit);
43503 
43507  ImportOptionsKit(ImportOptionsKit && in_that);
43508 
43512  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
43513 
43514  virtual ~ImportOptionsKit();
43515 
43516  HPS::Type ObjectType() const { return HPS::Type::StreamImportOptionsKit; };
43517 
43520  void Set(ImportOptionsKit const & in_kit);
43521 
43524  void Show(ImportOptionsKit & out_kit) const;
43525 
43529  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
43530 
43533  bool Empty() const;
43534 
43538  bool Equals(ImportOptionsKit const & in_kit) const;
43539 
43543  bool operator==(ImportOptionsKit const & in_kit) const;
43544 
43548  bool operator!=(ImportOptionsKit const & in_kit) const;
43549 
43552  ImportOptionsKit & SetToolkit(Toolkit const & in_toolkit);
43553 
43556  ImportOptionsKit & UnsetToolkit();
43557 
43561  bool ShowToolkit(HPS::Stream::Toolkit & out_toolkit) const;
43562 
43567  ImportOptionsKit & SetSegment(SegmentKey const & in_segment);
43568 
43571  ImportOptionsKit & UnsetSegment();
43572 
43576  bool ShowSegment(SegmentKey & out_segment) const;
43577 
43582  ImportOptionsKit & SetAlternateRoot(SegmentKey const & in_segment);
43583 
43586  ImportOptionsKit & UnsetAlternateRoot();
43587 
43591  bool ShowAlternateRoot(SegmentKey & out_segment) const;
43592 
43597  ImportOptionsKit & SetPortfolio(PortfolioKey const & in_portfolio);
43598 
43601  ImportOptionsKit & UnsetPortfolio();
43602 
43606  bool ShowPortfolio(PortfolioKey & out_portfolio) const;
43607 
43610  ImportOptionsKit & UnsetEverything();
43611 
43616  ImportOptionsKit & SetEventHandler(HPS::Stream::ImportEventHandler & in_handler, intptr_t in_type);
43617 
43621  ImportOptionsKit & UnsetEventHandler(intptr_t in_type);
43622 
43625  ImportOptionsKit & UnsetEventHandlers();
43626  };
43627 
43629  class HPS_API ImportResultsKit : public Object
43630  {
43631  public:
43633  ImportResultsKit();
43634 
43637  ImportResultsKit(ImportResultsKit const & in_kit);
43638 
43642  ImportResultsKit(ImportResultsKit && in_that);
43643 
43647  ImportResultsKit & operator=(ImportResultsKit && in_that);
43648 
43649  virtual ~ImportResultsKit();
43650 
43651  HPS::Type ObjectType() const { return HPS::Type::StreamImportResultsKit; };
43652 
43655  void Set(ImportResultsKit const & in_kit);
43656 
43659  void Show(ImportResultsKit & out_kit) const;
43660 
43664  ImportResultsKit & operator=(ImportResultsKit const & in_kit);
43665 
43668  bool Empty() const;
43669 
43673  bool Equals(ImportResultsKit const & in_kit) const;
43674 
43678  bool operator==(ImportResultsKit const & in_kit) const;
43679 
43683  bool operator!=(ImportResultsKit const & in_kit) const;
43684 
43689  ImportResultsKit & SetSegment(SegmentKey const & in_segment);
43690 
43694  ImportResultsKit & UnsetSegment();
43695 
43700  bool ShowSegment(SegmentKey & out_segment) const;
43701 
43706  ImportResultsKit & SetAlternateRoot(SegmentKey const & in_segment);
43707 
43711  ImportResultsKit & UnsetAlternateRoot();
43712 
43718  bool ShowAlternateRoot(SegmentKey & out_segment) const;
43719 
43724  ImportResultsKit & SetPortfolio(PortfolioKey const & in_portfolio);
43725 
43729  ImportResultsKit & UnsetPortfolio();
43730 
43736  bool ShowPortfolio(PortfolioKey & out_portfolio) const;
43737 
43742  ImportResultsKit & SetDefaultCamera(CameraKit const & in_camera);
43743 
43747  ImportResultsKit & UnsetDefaultCamera();
43748 
43752  bool ShowDefaultCamera(CameraKit & out_camera) const;
43753 
43754 
43760  ImportResultsKit & SetAlternateCameras(UTF8Array const & in_names, CameraKitArray & in_cameras);
43761 
43765  ImportResultsKit & UnsetAlternateCameras();
43766 
43771  bool ShowAlternateCameras(UTF8Array & out_names, CameraKitArray & out_cameras) const;
43772 
43773 
43776  ImportResultsKit & UnsetEverything();
43777  };
43778 
43780  class HPS_API ExportOptionsKit : public Object
43781  {
43782  public:
43784  ExportOptionsKit();
43785 
43788  ExportOptionsKit(ExportOptionsKit const & in_kit);
43789 
43793  ExportOptionsKit(ExportOptionsKit && in_that);
43794 
43798  ExportOptionsKit & operator=(ExportOptionsKit && in_that);
43799 
43803  static ExportOptionsKit GetDefault();
43804 
43805  virtual ~ExportOptionsKit();
43806 
43807  HPS::Type ObjectType() const { return HPS::Type::StreamExportOptionsKit; };
43808 
43811  void Set(ExportOptionsKit const & in_kit);
43812 
43815  void Show(ExportOptionsKit & out_kit) const;
43816 
43820  ExportOptionsKit & operator=(ExportOptionsKit const & in_kit);
43821 
43824  bool Empty() const;
43825 
43829  bool Equals(ExportOptionsKit const & in_kit) const;
43830 
43834  bool operator==(ExportOptionsKit const & in_kit) const;
43835 
43839  bool operator!=(ExportOptionsKit const & in_kit) const;
43840 
43843  ExportOptionsKit & SetToolkit(Toolkit const & in_toolkit);
43844 
43852  ExportOptionsKit & SetVertexCompression(bool in_state, unsigned int in_bits_per_vertex = 24);
43853 
43861  ExportOptionsKit & SetNormalCompression(bool in_state, unsigned int in_bits_per_normal = 10);
43862 
43868  ExportOptionsKit & SetParameterCompression(bool in_state, unsigned int in_bits_per_parameter = 8);
43869 
43877  ExportOptionsKit & SetColorCompression(bool in_state, unsigned int in_bits_per_color = 24);
43878 
43886  ExportOptionsKit & SetIndexCompression(bool in_state, unsigned int in_bits_per_index = 8);
43887 
43893  ExportOptionsKit & SetConnectivityCompression(bool in_state);
43894 
43900  ExportOptionsKit & SetSerializeTristrips(bool in_state);
43901 
43910  ExportOptionsKit & SetImageCompression(bool in_state, float in_quality = 0.75f);
43911 
43914  ExportOptionsKit & UnsetToolkit();
43915 
43918  ExportOptionsKit & UnsetVertexCompression();
43919 
43922  ExportOptionsKit & UnsetNormalCompression();
43923 
43926  ExportOptionsKit & UnsetParameterCompression();
43927 
43930  ExportOptionsKit & UnsetColorCompression();
43931 
43934  ExportOptionsKit & UnsetIndexCompression();
43935 
43938  ExportOptionsKit & UnsetConnectivityCompression();
43939 
43942  ExportOptionsKit & UnsetImageCompression();
43943 
43946  ExportOptionsKit & UnsetSerializeTristrips();
43947 
43950  ExportOptionsKit & UnsetEverything();
43951 
43955  bool ShowToolkit(HPS::Stream::Toolkit & out_toolkit) const;
43956 
43961  bool ShowVertexCompression(bool & out_state, unsigned int & out_bits_per_vertex) const;
43962 
43967  bool ShowNormalCompression(bool & out_state, unsigned int & out_bits_per_normal) const;
43968 
43973  bool ShowParameterCompression(bool & out_state, unsigned int & out_bits_per_parameter) const;
43974 
43979  bool ShowColorCompression(bool & out_state, unsigned int & out_bits_per_color) const;
43980 
43985  bool ShowIndexCompression(bool & out_state, unsigned int & out_bits_per_index) const;
43986 
43990  bool ShowConnectivityCompression(bool & out_state) const;
43991 
43996  bool ShowImageCompression(bool & out_state, float & out_quality) const;
43997 
44001  bool ShowSerializeTristrips(bool & out_state) const;
44002 
44007  ExportOptionsKit & SetEventHandler(HPS::Stream::ExportEventHandler & in_handler, intptr_t in_type);
44008 
44012  ExportOptionsKit & UnsetEventHandler(intptr_t in_type);
44013 
44016  ExportOptionsKit & UnsetEventHandlers();
44017  };
44018 
44021  class HPS_API ImportNotifier : public IONotifier
44022  {
44023  public:
44025  ImportNotifier();
44026 
44029  ImportNotifier(ImportNotifier const & in_that);
44030 
44035  ImportNotifier(IONotifier const & in_that);
44036 
44040  ImportNotifier(ImportNotifier && in_that);
44041 
44045  ImportNotifier & operator=(ImportNotifier && in_that);
44046 
44047  virtual ~ImportNotifier();
44048 
44049  HPS::Type ObjectType() const {return HPS::Type::StreamImportNotifier;};
44050 
44054  ImportNotifier & operator=(ImportNotifier const & in_that);
44055 
44058  void Assign(ImportNotifier const & in_that);
44059 
44063  ImportResultsKit GetResults() const;
44064  };
44065 
44068  class HPS_API ExportNotifier : public IONotifier
44069  {
44070  public:
44072  ExportNotifier();
44073 
44076  ExportNotifier(ExportNotifier const & in_that);
44077 
44082  ExportNotifier(IONotifier const & in_that);
44083 
44087  ExportNotifier(ExportNotifier && in_that);
44088 
44092  ExportNotifier & operator=(ExportNotifier && in_that);
44093 
44094  virtual ~ExportNotifier();
44095 
44096  HPS::Type ObjectType() const {return HPS::Type::StreamExportNotifier;};
44097 
44101  ExportNotifier & operator=(ExportNotifier const & in_that);
44102 
44105  void Assign(ExportNotifier const & in_that);
44106  };
44107 
44108 
44110  class HPS_API File
44111  {
44112  public:
44118  static ImportNotifier Import(char const * in_file_name, ImportOptionsKit const & in_options);
44119 
44125  static ImportNotifier Import(ByteArrayArray const & in_hsf_buffers, ImportOptionsKit const & in_options);
44126 
44133  static ExportNotifier Export(char const * in_file_name, SegmentKey const & in_segment, ExportOptionsKit const & in_options);
44134 
44141  static ExportNotifier Export(SegmentKey const & in_segment, ExportOptionsKit const & in_options, ByteArrayArray & out_hsf_buffers);
44142 
44143  private:
44145  File();
44146  };
44147 private:
44149  Stream();
44150 };
44151 
44155 
44160 class HPS_API Hardcopy
44161 {
44162 public:
44163 
44165  enum class SizeUnits
44166  {
44167  Centimeters,
44168  Inches,
44169  };
44170 
44172  enum class ResolutionUnits
44173  {
44174  DPCM,
44175  DPI,
44176  DotsPerCentimeter = DPCM,
44177  DotsPerInch = DPI,
44178  };
44179 
44181  class HPS_API File
44182  {
44183  public:
44184 
44186  class HPS_API ExportOptionsKit : public Object
44187  {
44188  public:
44190  ExportOptionsKit();
44191 
44194  ExportOptionsKit(ExportOptionsKit const & in_kit);
44195 
44199  ExportOptionsKit(ExportOptionsKit && in_that);
44200 
44204  ExportOptionsKit & operator=(ExportOptionsKit && in_that);
44205 
44206  virtual ~ExportOptionsKit();
44207 
44208  HPS::Type ObjectType() const { return HPS::Type::HardcopyExportOptionsKit; };
44209 
44212  void Set(ExportOptionsKit const & in_kit);
44213 
44216  void Show(ExportOptionsKit & out_kit) const;
44217 
44221  ExportOptionsKit & operator=(ExportOptionsKit const & in_kit);
44222 
44225  bool Empty() const;
44226 
44230  bool Equals(ExportOptionsKit const & in_kit) const;
44231 
44235  bool operator==(ExportOptionsKit const & in_kit) const;
44236 
44240  bool operator!=(ExportOptionsKit const & in_kit) const;
44241 
44242 
44243 
44244 
44250  bool ShowSize(float & out_width, float & out_height, Hardcopy::SizeUnits & out_units) const;
44251 
44259  ExportOptionsKit & SetSize(float in_width, float in_height, Hardcopy::SizeUnits in_units = Hardcopy::SizeUnits::Inches);
44260 
44263  ExportOptionsKit & UnsetSize();
44264 
44265 
44266 
44272  bool ShowResolution(float & out_resolution, Hardcopy::ResolutionUnits & out_units) const;
44273 
44280  ExportOptionsKit & SetResolution(float in_resolution, Hardcopy::ResolutionUnits in_units = Hardcopy::ResolutionUnits::DPI);
44281 
44284  ExportOptionsKit & UnsetResolution();
44285 
44286 
44287 
44290  bool ShowWYSIWYG(bool & out_onoff) const;
44291 
44303  ExportOptionsKit & SetWYSIWYG(bool in_onoff);
44304 
44307  ExportOptionsKit & UnsetWYSIWYG();
44308 
44309 
44312  ExportOptionsKit & UnsetEverything();
44313 
44314 
44318  static ExportOptionsKit GetDefault();
44319  };
44320 
44322  enum class Driver
44323  {
44324  PDF,
44325  Postscript
44326  };
44327 
44333  static IOResult Export(char const * in_filename, Driver in_driver_type, HPS::WindowKey const & in_window, ExportOptionsKit const & in_options);
44334  private:
44335  File();
44336  };
44337 
44338 #ifdef _MSC_VER
44339  class HPS_API GDI
44340  {
44341  public:
44342 
44344  class HPS_API ExportOptionsKit : public Object
44345  {
44346  public:
44348  ExportOptionsKit();
44349 
44352  ExportOptionsKit(ExportOptionsKit const & in_kit);
44353 
44357  ExportOptionsKit(ExportOptionsKit && in_that);
44358 
44362  ExportOptionsKit & operator=(ExportOptionsKit && in_that);
44363 
44364  virtual ~ExportOptionsKit();
44365 
44366  HPS::Type ObjectType() const { return HPS::Type::HardcopyExportOptionsKit; };
44367 
44370  void Set(ExportOptionsKit const & in_kit);
44371 
44374  void Show(ExportOptionsKit & out_kit) const;
44375 
44379  ExportOptionsKit & operator=(ExportOptionsKit const & in_kit);
44380 
44383  bool Empty() const;
44384 
44388  bool Equals(ExportOptionsKit const & in_kit) const;
44389 
44393  bool operator==(ExportOptionsKit const & in_kit) const;
44394 
44398  bool operator!=(ExportOptionsKit const & in_kit) const;
44399 
44400 
44401 
44402 
44406  bool ShowResolution(float & out_resolution) const;
44407 
44411  ExportOptionsKit & SetResolution(float in_resolution);
44412 
44415  ExportOptionsKit & UnsetResolution();
44416 
44417 
44418 
44419 
44422  bool ShowWYSIWYG(bool & out_onoff) const;
44423 
44427  ExportOptionsKit & SetWYSIWYG(bool in_onoff);
44428 
44431  ExportOptionsKit & UnsetWYSIWYG();
44432 
44433 
44436  ExportOptionsKit & UnsetEverything();
44437  };
44438 
44445  static IOResult Export(intptr_t hdc, intptr_t attribdc, HPS::WindowKey const & window, ExportOptionsKit const & options);
44446 
44447  private:
44448  GDI();
44449  };
44450 #endif
44451 
44452 private:
44453  Hardcopy();
44454 };
44455 
44459 
44461 class HPS_API OBJ
44462 {
44463 public:
44464 
44466  class HPS_API ImportOptionsKit : public Object
44467  {
44468  public:
44470  ImportOptionsKit();
44471 
44474  ImportOptionsKit(ImportOptionsKit const & in_kit);
44475 
44479  ImportOptionsKit(ImportOptionsKit && in_that);
44480 
44484  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
44485 
44486  virtual ~ImportOptionsKit();
44487 
44488  HPS::Type ObjectType() const { return HPS::Type::OBJImportOptionsKit; };
44489 
44492  void Set(ImportOptionsKit const & in_kit);
44493 
44496  void Show(ImportOptionsKit & out_kit) const;
44497 
44501  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
44502 
44505  bool Empty() const;
44506 
44510  bool Equals(ImportOptionsKit const & in_kit) const;
44511 
44515  bool operator==(ImportOptionsKit const & in_kit) const;
44516 
44520  bool operator!=(ImportOptionsKit const & in_kit) const;
44521 
44526  ImportOptionsKit & SetSegment(SegmentKey const & in_segment);
44527 
44530  ImportOptionsKit & UnsetSegment();
44531 
44535  bool ShowSegment(SegmentKey & out_segment) const;
44536 
44541  ImportOptionsKit & SetPortfolio(PortfolioKey const & in_portfolio);
44542 
44545  ImportOptionsKit & UnsetPortfolio();
44546 
44550  bool ShowPortfolio(PortfolioKey & out_portfolio) const;
44551 
44557  ImportOptionsKit & SetHandedness(Drawing::Handedness const & in_handedness);
44558 
44561  ImportOptionsKit & UnsetHandedness();
44562 
44566  bool ShowHandedness(Drawing::Handedness & out_handedness) const;
44567 
44570  ImportOptionsKit & UnsetEverything();
44571  };
44572 
44574  class HPS_API ImportResultsKit : public Object
44575  {
44576  public:
44578  ImportResultsKit();
44579 
44582  ImportResultsKit(ImportResultsKit const & in_kit);
44583 
44587  ImportResultsKit(ImportResultsKit && in_that);
44588 
44592  ImportResultsKit & operator=(ImportResultsKit && in_that);
44593 
44594  virtual ~ImportResultsKit();
44595 
44596  HPS::Type ObjectType() const { return HPS::Type::OBJImportResultsKit; };
44597 
44600  void Set(ImportResultsKit const & in_kit);
44601 
44604  void Show(ImportResultsKit & out_kit) const;
44605 
44609  ImportResultsKit & operator=(ImportResultsKit const & in_kit);
44610 
44613  bool Empty() const;
44614 
44618  bool Equals(ImportResultsKit const & in_kit) const;
44619 
44623  bool operator==(ImportResultsKit const & in_kit) const;
44624 
44628  bool operator!=(ImportResultsKit const & in_kit) const;
44629 
44634  ImportResultsKit & SetSegment(SegmentKey const & in_segment);
44635 
44639  ImportResultsKit & UnsetSegment();
44640 
44645  bool ShowSegment(SegmentKey & out_segment) const;
44646 
44651  ImportResultsKit & SetPortfolio(PortfolioKey const & in_portfolio);
44652 
44656  ImportResultsKit & UnsetPortfolio();
44657 
44663  bool ShowPortfolio(PortfolioKey & out_portfolio) const;
44664 
44669  ImportResultsKit & SetHandedness(Drawing::Handedness const & in_handedness);
44670 
44674  ImportResultsKit & UnsetHandedness();
44675 
44680  bool ShowHandedness(Drawing::Handedness & out_handedness) const;
44681 
44684  ImportResultsKit & UnsetEverything();
44685  };
44686 
44689  class HPS_API ImportNotifier : public IONotifier
44690  {
44691  public:
44693  ImportNotifier();
44694 
44697  ImportNotifier(ImportNotifier const & in_that);
44698 
44703  ImportNotifier(IONotifier const & in_that);
44704 
44708  ImportNotifier(ImportNotifier && in_that);
44709 
44713  ImportNotifier & operator=(ImportNotifier && in_that);
44714 
44715  virtual ~ImportNotifier();
44716 
44717  HPS::Type ObjectType() const {return HPS::Type::OBJImportNotifier;};
44718 
44722  ImportNotifier & operator=(ImportNotifier const & in_that);
44723 
44726  void Assign(ImportNotifier const & in_that);
44727 
44731  ImportResultsKit GetResults() const;
44732  };
44733 
44734 
44736  class HPS_API File
44737  {
44738  public:
44744  static ImportNotifier Import(char const * in_file_name, ImportOptionsKit const & in_options);
44745 
44746  private:
44748  File();
44749  };
44750 private:
44752  OBJ();
44753 };
44754 
44758 
44760 class HPS_API STL
44761 {
44762 public:
44763 
44765  class HPS_API ImportOptionsKit : public Object
44766  {
44767  public:
44769  ImportOptionsKit();
44770 
44773  ImportOptionsKit(ImportOptionsKit const & in_kit);
44774 
44778  ImportOptionsKit(ImportOptionsKit && in_that);
44779 
44783  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
44784 
44785  virtual ~ImportOptionsKit();
44786 
44787  HPS::Type ObjectType() const { return HPS::Type::STLImportOptionsKit; };
44788 
44791  void Set(ImportOptionsKit const & in_kit);
44792 
44795  void Show(ImportOptionsKit & out_kit) const;
44796 
44800  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
44801 
44804  bool Empty() const;
44805 
44809  bool Equals(ImportOptionsKit const & in_kit) const;
44810 
44814  bool operator==(ImportOptionsKit const & in_kit) const;
44815 
44819  bool operator!=(ImportOptionsKit const & in_kit) const;
44820 
44824  static ImportOptionsKit GetDefault();
44825 
44830  ImportOptionsKit & SetSegment(SegmentKey const & in_segment);
44831 
44839  ImportOptionsKit & SetOptimization(bool in_state, ShellOptimizationOptionsKit const & in_optimization_kit);
44840 
44847  ImportOptionsKit & SetOptimization(ShellOptimizationOptionsKit const & in_optimization_kit);
44848 
44849 
44852  ImportOptionsKit & UnsetSegment();
44853 
44856  ImportOptionsKit & UnsetOptimization();
44857 
44860  ImportOptionsKit & UnsetEverything();
44861 
44862 
44866  bool ShowSegment(SegmentKey & out_segment) const;
44867 
44872  bool ShowOptimization(bool & out_state, ShellOptimizationOptionsKit & out_optimization_options) const;
44873  };
44874 
44876  class HPS_API ImportResultsKit : public Object
44877  {
44878  public:
44880  ImportResultsKit();
44881 
44884  ImportResultsKit(ImportResultsKit const & in_kit);
44885 
44889  ImportResultsKit(ImportResultsKit && in_that);
44890 
44894  ImportResultsKit & operator=(ImportResultsKit && in_that);
44895 
44896  virtual ~ImportResultsKit();
44897 
44898  HPS::Type ObjectType() const { return HPS::Type::STLImportResultsKit; };
44899 
44902  void Set(ImportResultsKit const & in_kit);
44903 
44906  void Show(ImportResultsKit & out_kit) const;
44907 
44911  ImportResultsKit & operator=(ImportResultsKit const & in_kit);
44912 
44915  bool Empty() const;
44916 
44920  bool Equals(ImportResultsKit const & in_kit) const;
44921 
44925  bool operator==(ImportResultsKit const & in_kit) const;
44926 
44930  bool operator!=(ImportResultsKit const & in_kit) const;
44931 
44936  ImportResultsKit & SetSegment(SegmentKey const & in_segment);
44937 
44941  ImportResultsKit & UnsetSegment();
44942 
44947  bool ShowSegment(SegmentKey & out_segment) const;
44948 
44951  ImportResultsKit & UnsetEverything();
44952  };
44953 
44956  class HPS_API ImportNotifier : public IONotifier
44957  {
44958  public:
44960  ImportNotifier();
44961 
44964  ImportNotifier(ImportNotifier const & in_that);
44965 
44970  ImportNotifier(IONotifier const & in_that);
44971 
44975  ImportNotifier(ImportNotifier && in_that);
44976 
44980  ImportNotifier & operator=(ImportNotifier && in_that);
44981 
44982  virtual ~ImportNotifier();
44983 
44984  HPS::Type ObjectType() const {return HPS::Type::STLImportNotifier;};
44985 
44989  ImportNotifier & operator=(ImportNotifier const & in_that);
44990 
44993  void Assign(ImportNotifier const & in_that);
44994 
44998  ImportResultsKit GetResults() const;
44999  };
45000 
45001 
45003  class HPS_API File
45004  {
45005  public:
45011  static ImportNotifier Import(char const * in_file_name, ImportOptionsKit const & in_options);
45012 
45013  private:
45015  File();
45016  };
45017 private:
45019  STL();
45020 };
45021 
45022 }
45023 
45024 #ifdef _MSC_VER
45025 # pragma warning(pop)
45026 #endif
45027 
45028 #endif
45029 
45030 
HPS::Type ObjectType() const
Definition: hps.h:40161
Rotation
Definition: hps.h:1607
HPS::Type ObjectType() const
Definition: hps.h:27085
bool Empty() const
Definition: hps.h:6859
CameraPoint(Point const &in_point)
Definition: hps.h:5810
Alignment
Definition: hps.h:1540
HPS::Type ObjectType() const
Definition: hps.h:19458
Space
Definition: hps.h:561
WindowPoint Location
Location in window space of the mouse cursor.
Definition: hps.h:41922
Definition: hps.h:3272
Definition: hps.h:6049
Channel
Definition: hps.h:945
HPS::Type ObjectType() const
Definition: hps.h:24257
Handedness
Definition: hps.h:1276
Definition: hps.h:14304
Definition: hps.h:1051
Definition: hps.h:12077
ColorSource
Definition: hps.h:1933
HPS::Type ObjectType() const
Definition: hps.h:17186
bool HasAll(MouseButtons const &in_buttons) const
Definition: hps.h:41708
HPS::Type ObjectType() const
Definition: hps.h:36462
Event(intptr_t in_channel=0)
Definition: hps.h:6163
Definition: hps.h:18304
HPS::Type ObjectType() const
Definition: hps.h:44717
Cuboid_3D(Point_3D< F > const &in_min, Point_3D< F > const &in_max)
Definition: hps.h:3764
HPS::ByteArray user_data
Definition: hps.h:43444
float alpha
Definition: hps.h:4303
Definition: hps.h:34834
HPS::Type ObjectType() const
Definition: hps.h:36069
bool operator==(Touch const &in_that) const
Definition: hps.h:6453
Both cylinder ends will be capped.
void X1(bool in_state)
Definition: hps.h:41729
Search for all attributes, geometry, segments, includes and includers.
void Shift(bool in_state)
Definition: hps.h:41379
HPS::Info::Code code
The error code for this ErrorEvent.
Definition: hps.h:41135
InformationEvent(char const *in_message)
Definition: hps.h:40935
size_t display_list_tristrip_count
Number of tristrips drawn from display lists during the last update.
Definition: hps.h:4821
HPS::Type ObjectType() const
Definition: hps.h:34496
Definition: hps.h:8717
HPS::Type ObjectType() const
Definition: hps.h:21988
HPS::Type ObjectType() const
Definition: hps.h:23785
size_t extent_culled_segment_count
Number of segments culled because of extent culling during the last update.
Definition: hps.h:4827
HPS::Type ObjectType() const
Definition: hps.h:24531
Action
Definition: hps.h:41520
Definition: hps.h:42584
Orientation
Definition: hps.h:537
Definition: hps.h:20796
Code
Definition: hps.h:134
Definition: sprk_exchange.h:43
Algorithm
Definition: hps.h:1331
Multiline strings will be left justfied.
Definition: hps.h:39978
HPS::Type ObjectType() const
Definition: hps.h:15063
virtual bool Equals(StandAloneWindowEvent const &in_that) const
Definition: hps.h:41190
HPS::Type ObjectType() const
Definition: hps.h:8648
HPS::Type ObjectType() const
Definition: hps.h:28313
Definition: hps.h:42842
Event * Clone() const
Definition: hps.h:41033
Definition: hps.h:13359
MouseEvent(Action in_action, float in_wheel_delta, WindowPoint in_location=WindowPoint(0, 0, 0), ModifierKeys in_modifier=ModifierKeys(), size_t in_click_count=0)
Definition: hps.h:41839
Definition: hps.h:44461
virtual HandleResult Handle(Event const *in_event)
Definition: hps.h:40821
ImportStatusEvent()
Definition: hps.h:41278
HPS::Type ObjectType() const
Definition: hps.h:21603
HPS::Type ObjectType() const
Definition: hps.h:36244
Definition: hps.h:13867
HPS::Type ObjectType() const
Definition: hps.h:26048
Definition: hps.h:42512
virtual bool Equals(TouchEvent const &in_that) const
Definition: hps.h:41585
size_t frustum_culled_segment_count
Number of segments culled because of frustum culling during the last update.
Definition: hps.h:4826
HPS::Type ObjectType() const
Definition: hps.h:30353
HPS::Type ObjectType() const
Definition: hps.h:25659
HPS::Type ObjectType() const
Definition: hps.h:11726
static MouseButtons ButtonX2()
Definition: hps.h:41784
Definition: hps.h:19896
A unitless linear scaling factor. A value of 2.0 will cause markers to be rendered twice as large...
The clip region is specified in world coordinated.
ErrorEvent(char const *in_message, HPS::Info::Code in_code)
Definition: hps.h:41082
void SetKeyboardCodes(size_t in_keyboardcode_count, HPS::KeyboardCode const in_keyboardcodes[])
Definition: hps.h:42028
Definition: hps.h:44876
Definition: hps.h:38137
Definition: hps.h:19250
HPS::Type ObjectType() const
Definition: hps.h:37957
ObjectPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5707
Definition: hps.h:1506
Definition: hps.h:43138
InnerWindowPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5955
bool Middle() const
Definition: hps.h:41694
Definition: hps.h:467
Driver
Definition: hps.h:154
HPS::Type ObjectType() const
Definition: hps.h:42068
static HPS_INLINE bool IsInfinite(float const &a)
Definition: hps.h:2205
Definition: hps.h:35565
HPS::Type ObjectType() const
Definition: hps.h:39305
CappingLevel
Definition: hps.h:1739
Definition: hps.h:41930
virtual void Handle(DriverEvent const *in_event)
Definition: hps.h:8732
HPS::Type ObjectType() const
Definition: hps.h:23512
HPS::Type ObjectType() const
Definition: hps.h:35997
Definition: hps.h:9467
Object space units ignoring any scaling components in modelling matrices.
HPS::Type ObjectType() const
Definition: hps.h:12871
size_t dot_3d_count
Number of 3D dots drawn during the last update.
Definition: hps.h:4809
HPS::Type ObjectType() const
Definition: hps.h:42180
HPS::Type ObjectType() const
Definition: hps.h:20640
Definition: hps.h:43082
Definition: hps.h:26672
HPS::Type ObjectType() const
Definition: hps.h:13890
InputEvent()
Definition: hps.h:41464
An InvalidSpecificationException is thrown when a method is called with non-sensical or contradictory...
Definition: hps.h:5558
Definition: hps.h:35532
static MouseButtons ButtonRight()
Definition: hps.h:41772
HPS::Type ObjectType() const
Definition: hps.h:29098
HPS_INLINE bool Intersecting(int dimension, Cuboid_3D const &cuboid) const
Definition: hps.h:3871
Definition: hps.h:5598
Definition: hps.h:35832
KeyboardEvent(KeyboardEvent::Action in_action, KeyboardCodeArray const &in_keyboardcodes, ModifierKeys in_modifiers=ModifierKeys())
Definition: hps.h:41967
static ModifierKeys KeyMeta()
Definition: hps.h:41438
HPS::Type ObjectType() const
Definition: hps.h:35732
Visualize will perform runtime query of the 3D capabilities of the Operating System and graphics card...
Definition: hps.h:1517
Definition: hps.h:23678
HPS::Type ObjectType() const
Definition: hps.h:37112
Definition: hps.h:16777
HPS::Type ObjectType() const
Definition: hps.h:44096
bool Equals(MouseButtons const &in_that) const
Definition: hps.h:41659
Cuboid_3D(Cuboid_3D< D > const &that)
Definition: hps.h:3750
Definition: hps.h:35191
HPS::Type ObjectType() const
Definition: hps.h:19697
HPS::Type ObjectType() const
Definition: hps.h:39477
HPS::Type ObjectType() const
Definition: hps.h:23710
HPS::Type ObjectType() const
Definition: hps.h:35270
Definition: hps.h:22536
HPS::Type ObjectType() const
Definition: hps.h:16892
MouseButtons()
Definition: hps.h:41654
HPS::Type ObjectType() const
Definition: hps.h:38546
Definition: hps.h:20408
Time GetTimeStamp() const
Definition: hps.h:6185
Definition: hps.h:45003
void Left(bool in_state)
Definition: hps.h:41717
HPS::Type ObjectType() const
Definition: hps.h:22506
NormalizedPoint(Point const &in_point)
Definition: hps.h:5860
HPS::Type ObjectType() const
Definition: hps.h:24059
Event * Clone() const
Definition: hps.h:40850
static HPS_INLINE Cuboid_3D Invalid()
Definition: hps.h:3799
Definition: hps.h:42649
bool HasAny(MouseButtons const &in_buttons) const
Definition: hps.h:41713
Renderer
Definition: hps.h:1588
HPS::Type ObjectType() const
Definition: hps.h:34232
Definition: hps.h:40338
KeyboardEvent()
Definition: hps.h:41943
HPS::Type ObjectType() const
Definition: hps.h:7372
Definition: hps.h:37924
HPS_INLINE bool Contains(Cuboid_3D const &contained) const
Definition: hps.h:3992
ObjectPoint(Point const &in_point)
Definition: hps.h:5710
HPS::Type ObjectType() const
Definition: hps.h:17773
Definition: hps.h:33682
Object space units ignoring any scaling components in modelling matrices.
Definition: hps.h:40081
Definition: hps.h:4380
Definition: hps.h:6668
Definition: hps.h:1325
Definition: hps.h:40871
Definition: hps.h:24499
Point_3D< F > min
Definition: hps.h:3734
StandAloneWindowEvent(Event const &in_event)
Definition: hps.h:41164
static ModifierKeys KeyAlt()
Definition: hps.h:41434
bool IsConsumable() const
Definition: hps.h:6188
HPS::ByteArray user_data
Definition: hps.h:43461
Definition: hps.h:1048
size_t GetHash() const
Definition: hps.h:1678
MaterialPreference
Definition: hps.h:1756
size_t line_dc_count
Number of DC lines drawn during the last update.
Definition: hps.h:4810
KeyboardEvent(KeyboardEvent::Action in_action, size_t in_keyboardcode_count, HPS::KeyboardCode const in_keyboardcodes[], ModifierKeys in_modifiers=ModifierKeys())
Definition: hps.h:41956
Mobility
Definition: hps.h:194
HPS::Type ObjectType() const
Definition: hps.h:13382
ScreenRangePoint(Point const &in_point)
Definition: hps.h:5908
Definition: hps.h:14743
InterpolationAlgorithm
Definition: hps.h:1523
Fill
Definition: hps.h:1924
Cuboid_3D(Rectangle const &that)
Definition: hps.h:3787
Definition: hps.h:23953
Definition: hps.h:19435
HPS::Type ObjectType() const
Definition: hps.h:27590
HPS::Type ObjectType() const
Definition: hps.h:19273
char At(size_t in_index) const
Definition: hps.h:6902
Definition: hps.h:40150
Definition: hps.h:4406
bool HasAny(ModifierKeys const &in_keys) const
Definition: hps.h:41374
HPS::Type ObjectType() const
Definition: hps.h:36124
Definition: hps.h:129
ReferenceFrame
Definition: hps.h:1555
size_t polygon_dc_count
Number of DC polygons drawn during the last update.
Definition: hps.h:4814
Definition: hps.h:26016
Bloom Shape.
Definition: hps.h:42259
Definition: hps.h:3732
Definition: hps.h:3729
HPS::Type ObjectType() const
Definition: hps.h:17100
GreekingUnits
Definition: hps.h:1642
Definition: hps.h:18798
Definition: hps.h:7427
HPS::Type ObjectType() const
Definition: hps.h:12280
InnerConeUnits
Definition: hps.h:486
Definition: hps.h:26882
InnerPixelPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:6004
HPS_INLINE bool Intersecting(Point_3D< F > const &point1, Point_3D< F > const &point2) const
Definition: hps.h:3904
static MouseButtons ButtonX1()
Definition: hps.h:41780
KeyPath & Append(Key const &in_key)
UpdateCompletedEvent()
Definition: hps.h:41240
Definition: hps.h:18517
Definition: hps.h:3419
OuterConeUnits
Definition: hps.h:472
Definition: hps.h:6435
void X2(bool in_state)
Definition: hps.h:41733
HPS::Type ObjectType() const
Definition: hps.h:19057
HPS::Type ObjectType() const
Definition: hps.h:40672
size_t culled_display_list_tristrip_count
Number of tristrips from display lists culled during the last update.
Definition: hps.h:4823
HPS::Type ObjectType() const
Definition: hps.h:39574
HPS::Type ObjectType() const
Definition: hps.h:14491
Definition: hps.h:15039
Definition: hps.h:2006
HPS::Type ObjectType() const
Definition: hps.h:33715
void SetKeyboardCodes(HPS::KeyboardCodeArray const &in_keyboardcodes)
Definition: hps.h:42035
HPS::Type ObjectType() const
Definition: hps.h:26984
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:41609
Definition: hps.h:43351
Definition: hps.h:42738
HPS::Type ObjectType() const
Definition: hps.h:12754
HPS::Type ObjectType() const
Definition: hps.h:25241
Definition: hps.h:441
HPS::Type ObjectType() const
Definition: hps.h:36575
Definition: hps.h:21966
Channel
Definition: hps.h:904
HPS::Info::Code code
The warning code for this WarningEvent.
Definition: hps.h:41064
AreaUnits
Definition: hps.h:1469
Definition: sprk_publish.h:42
HPS_INLINE F Volume() const
Definition: hps.h:3841
HPS::Type ObjectType() const
Definition: hps.h:12101
Definition: hps.h:8599
Definition: hps.h:26962
Definition: hps.h:19674
HPS::Type ObjectType() const
Definition: hps.h:34856
Action
Definition: hps.h:41146
Event * Clone() const
Definition: hps.h:40962
HPS::Type ObjectType() const
Definition: hps.h:14327
Definition: hps.h:4655
HPS::Type ObjectType() const
Definition: hps.h:43807
HPS::Type ObjectType() const
Definition: hps.h:27691
Definition: hps.h:43323
size_t TapCount
Number of taps for this Touch.
Definition: hps.h:6468
Definition: hps.h:21386
Definition: hps.h:4537
HPS::Type ObjectType() const
Definition: hps.h:38075
HPS::Type ObjectType() const
Definition: hps.h:34369
Definition: hps.h:1396
Definition: hps.h:17985
Definition: hps.h:879
Definition: hps.h:5584
TouchEvent(Action in_action, TouchArray const &in_touches, ModifierKeys in_modifier=ModifierKeys())
Definition: hps.h:41542
void Merge(size_t count, Point_3D< F > const *points)
Definition: hps.h:3950
Border
Definition: hps.h:264
UpdateControl
Definition: hps.h:175
bool HasAll(ModifierKeys const &in_keys) const
Definition: hps.h:41369
Time update_time
Time taken by the last update.
Definition: hps.h:4829
Definition: hps.h:38042
Definition: hps.h:36222
size_t vector_culled_segment_count
Number of segments culled because of vector culling during the last update.
Definition: hps.h:4828
Definition: hps.h:7417
HPS::Type ObjectType() const
Definition: hps.h:23262
virtual bool Equals(KeyboardEvent const &in_that) const
Definition: hps.h:42004
HPS::Type ObjectType() const
Definition: hps.h:21528
WarningEvent(Event const &in_event)
Definition: hps.h:41015
Definition: hps.h:37135
HPS::Type ObjectType() const
Definition: hps.h:11598
The geometry inside the clip region is drawn. Everything outside of it is clipped.
Default
Definition: hps.h:1943
Definition: hps.h:1724
static ModifierKeys KeyShift()
Definition: hps.h:41426
Definition: hps.h:149
HPS::Type ObjectType() const
Definition: hps.h:28824
Shape
Definition: hps.h:1073
bool IsValid() const
Definition: hps.h:6852
Definition: hps.h:20617
Definition: hps.h:1535
Cuboid_3D()
Definition: hps.h:3742
ErrorEvent(Event const &in_event)
Definition: hps.h:41086
size_t GetWStrLength() const
Definition: hps.h:6881
Event * Clone() const
Definition: hps.h:40915
HPS::Type ObjectType() const
Definition: hps.h:11187
AppendMode
Definition: hps.h:332
Definition: hps.h:8628
Definition: hps.h:25489
static void Free(void *in_pointer)
bool X1() const
Definition: hps.h:41698
Definition: hps.h:236
Definition: hps.h:41274
HPS_INLINE void Merge(Point_3D< F > const &point)
Definition: hps.h:3935
void Meta(bool in_state)
Definition: hps.h:41391
Definition: hps.h:6620
PixelPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:6103
Definition: hps.h:27063
Definition: hps.h:43069
HPS::Type ObjectType() const
Definition: hps.h:14769
UpdateStatus
Definition: hps.h:164
HPS_INLINE bool IsValid() const
Definition: hps.h:3792
HPS::Type ObjectType() const
Definition: hps.h:38658
Action action
The action for this StandAloneWindowEvent.
Definition: hps.h:41211
Definition: hps.h:21189
Quality
Definition: hps.h:1057
ResolutionUnits
Definition: hps.h:44172
Event * Clone() const
Definition: hps.h:41474
ModifierKeys ModifierKeyState
The modifier keys which are active for this InputEvent.
Definition: hps.h:41511
Definition: hps.h:4479
TimerTickEvent(Event const &in_event)
Definition: hps.h:40840
Component
Definition: hps.h:352
Definition: hps.h:44574
Definition: hps.h:5702
WindowPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:6054
HPS::Type ObjectType() const
Definition: hps.h:12367
Definition: hps.h:12494
Default
Definition: hps.h:1897
HPS::Type ObjectType() const
Definition: hps.h:10816
Definition: hps.h:17077
Definition: hps.h:2145
Definition: hps.h:24947
InformationEvent()
Definition: hps.h:40931
bool Equals(GlyphPoint const &in_that) const
Definition: hps.h:5078
Definition: hps.h:37876
Definition: hps.h:11702
Definition: hps.h:13948
size_t triangle_3d_count
Number of 3D triangles drawn during the last update.
Definition: hps.h:4813
Definition: hps.h:11163
Definition: hps.h:44956
bool Shift() const
Definition: hps.h:41351
SizeToleranceUnits
Definition: hps.h:1629
HPS::Type ObjectType() const
Definition: hps.h:38782
Definition: hps.h:1776
HPS_INLINE bool Contains(Point_3D< F > const &contained, F epsilon) const
Definition: hps.h:4021
Definition: hps.h:43029
Cap
Definition: hps.h:1848
Point_3D< F > max
Definition: hps.h:3736
HPS::Type ObjectType() const
Definition: hps.h:7455
Definition: hps.h:11431
Definition: hps.h:20964
Definition: hps.h:14054
HPS::Type ObjectType() const
Definition: hps.h:44488
HPS::Type ObjectType() const
Definition: hps.h:44596
MouseEvent()
Definition: hps.h:41821
Definition: hps.h:14127
HPS::Type ObjectType() const
Definition: hps.h:12206
Definition: hps.h:20168
Definition: hps.h:27334
Definition: hps.h:1067
HPS::Type ObjectType() const
Definition: hps.h:16799
Definition: hps.h:12402
Definition: hps.h:32489
HPS::Type ObjectType() const
Definition: hps.h:35315
Definition: hps.h:12730
static const float Infinity
Definition: hps.h:2200
InsetBehavior
Definition: hps.h:1829
HPS::Type ObjectType() const
Definition: hps.h:25167
Definition: hps.h:5671
static HPS_INLINE bool IsNAN(float const &a)
Definition: hps.h:2213
HPS::Type ObjectType() const
Definition: hps.h:13778
HPS::Type ObjectType() const
Definition: hps.h:27284
WindowPoint Location
Location in window space for this Touch.
Definition: hps.h:6467
HPS::Type ObjectType() const
Definition: hps.h:35505
HPS::Type ObjectType() const
Definition: hps.h:37802
HPS_INLINE void Merge(Cuboid_3D const &cuboid)
Definition: hps.h:3914
Algorithm
Definition: hps.h:1457
Definition: hps.h:42158
Definition: hps.h:8667
Decimation
Definition: hps.h:1014
StaticModel
Definition: hps.h:1115
Definition: hps.h:38758
Granularity
Definition: hps.h:1378
Definition: hps.h:37033
DisplayLists
Definition: hps.h:1093
Definition: hps.h:10994
Search the current segment only.
size_t display_list_line_3d_count
Number of lines drawn from display lists during the last update.
Definition: hps.h:4818
Definition: hps.h:44068
Definition: hps.h:2659
Definition: hps.h:43780
Definition: hps.h:556
KeyboardEvent(Event const &in_event)
Definition: hps.h:41976
Definition: hps.h:21237
Definition: hps.h:35242
ClipOperation
Definition: hps.h:1305
HPS::Type ObjectType() const
Definition: hps.h:8990
Definition: hps.h:2572
Definition: hps.h:30320
Method
Definition: hps.h:1447
Definition: hps.h:37079
HPS::Type ObjectType() const
Definition: hps.h:26704
Definition: hps.h:44110
Parameterization
Definition: hps.h:959
Definition: hps.h:4297
Definition: hps.h:37330
Definition: hps.h:36548
FocusLostEvent()
Definition: hps.h:41219
CuttingLevel
Definition: hps.h:1748
Channel
Definition: hps.h:925
Definition: hps.h:9550
Definition: hps.h:44765
HandleResult
Definition: hps.h:40811
Definition: hps.h:39283
bool operator!=(GlyphPoint const &in_that) const
Definition: hps.h:5090
Definition: hps.h:5950
UTF8 message
The error message for this ErrorEvent.
Definition: hps.h:41134
Value
Definition: hps.h:1428
Definition: hps.h:1087
static HPS_INLINE bool IsAbnormal(float const &a)
Definition: hps.h:2221
Code
Definition: hps.h:104
HPS::Type ObjectType() const
Definition: hps.h:26200
Event * Clone() const
Definition: hps.h:41227
virtual bool Equals(MouseEvent const &in_that) const
Definition: hps.h:41875
Definition: hps.h:42428
Definition: hps.h:41804
ErrorEvent()
Definition: hps.h:41073
Definition: hps.h:41140
Justification
Definition: hps.h:1563
The vertex colors applied to faces.
Definition: hps.h:6540
HPS::Type ObjectType() const
Definition: hps.h:14151
Definition: hps.h:35371
An InvalidOperationException is thrown when an operation is not supported on the current platform...
Definition: hps.h:5576
Definition: hps.h:42528
ErrorEvent(char const *in_message)
Definition: hps.h:41077
UpdateCompletedEvent(Event const &in_event)
Definition: hps.h:41247
Definition: hps.h:41515
FrameSize
Definition: hps.h:205
Definition: hps.h:2160
Definition: hps.h:9358
Definition: hps.h:23763
Definition: hps.h:12183
Justification
Definition: hps.h:1865
Definition: hps.h:21721
HPS::Type ObjectType() const
Definition: hps.h:11924
Definition: hps.h:40649
Definition: hps.h:38085
Definition: hps.h:43448
HPS::Type ObjectType() const
Definition: hps.h:19920
Definition: hps.h:1702
Definition: hps.h:1483
HPS::Type ObjectType() const
Definition: hps.h:22337
bool None() const
Definition: hps.h:41682
Definition: hps.h:316
Definition: hps.h:1422
HPS::Type ObjectType() const
Definition: hps.h:8773
HPS::Type ObjectType() const
Definition: hps.h:37066
Definition: hps.h:43230
HPS::Type ObjectType() const
Definition: hps.h:35219
Definition: hps.h:17750
GreekingMode
Definition: hps.h:1654
HPS::Type ObjectType() const
Definition: hps.h:20432
Definition: hps.h:36440
Definition: hps.h:42542
HPS::KeyboardCodeArray KeyboardCodes
Array of keyboard codes for this KeyboardEvent.
Definition: hps.h:42040
Operation
Definition: hps.h:455
Definition: hps.h:1441
HPS::Type ObjectType() const
Definition: hps.h:37647
Type
Definition: hps.h:2012
WorldPoint(Point const &in_point)
Definition: hps.h:5760
HPS::TouchArray Touches
Array of Touches for this TouchEvent.
Definition: hps.h:41634
Definition: hps.h:44736
Definition: hps.h:42470
HPS::Type ObjectType() const
Definition: hps.h:10013
static HPS_INLINE bool Equals(float const &a, float const &b, int tolerance=32)
Definition: hps.h:2492
Definition: hps.h:22736
HPS::Type ObjectType() const
Definition: hps.h:6699
Definition: hps.h:34985
Definition: hps.h:18058
TouchEvent(Event const &in_event)
Definition: hps.h:41557
friend bool operator!=(char const *in_left, UTF8 const &in_right)
Definition: hps.h:6984
Definition: hps.h:5061
Definition: hps.h:39551
Definition: hps.h:44760
Definition: hps.h:35472
Definition: hps.h:4236
Relation
Definition: hps.h:378
Action
Definition: hps.h:41935
ChannelMapping
Definition: hps.h:1028
HPS::Type ObjectType() const
Definition: hps.h:22854
Definition: hps.h:6797
IOResult result
Enumeration indicating the category of the exception.
Definition: hps.h:5593
HPS::Type ObjectType() const
Definition: hps.h:39124
HPS::Type ObjectType() const
Definition: hps.h:39763
Definition: hps.h:24037
Definition: hps.h:5803
HPS::Type ObjectType() const
Definition: hps.h:42453
bool Alt() const
Definition: hps.h:41359
Definition: hps.h:41650
ToleranceUnits
Definition: hps.h:361
Definition: hps.h:24816
Definition: hps.h:27558
HPS::Type ObjectType() const
Definition: hps.h:12680
SizeUnits
Definition: hps.h:1816
Type
Definition: hps.h:2029
HPS::Type ObjectType() const
Definition: hps.h:17904
The vertex colors applied to faces.
HPS::Type ObjectType() const
Definition: hps.h:35560
RelationTest
Definition: hps.h:388
Definition: hps.h:39455
Definition: hps.h:8696
Definition: hps.h:42976
Type
Definition: hps.h:323
HPS::Type ObjectType() const
Definition: hps.h:14915
Behavior
Definition: hps.h:570
Definition: hps.h:5753
Ambient Occulsion Quality.
HPS::Type ObjectType() const
Definition: hps.h:6774
HPS::KeyboardEvent::Action CurrentAction
The action for the keyboard codes for this KeyboardEvent.
Definition: hps.h:42041
Definition: hps.h:40827
HPS::Type ObjectType() const
Definition: hps.h:18821
Style Append Mode.
ImageFormat
Definition: hps.h:220
Definition: hps.h:38807
Definition: hps.h:25637
Definition: hps.h:42046
An InvalidLicenseException is thrown when trying to run Visualize with an invalid license...
Definition: hps.h:5567
float blue
Definition: hps.h:4302
A grid of lines will be drawn in place of characters below the greeking limit.
Definition: hps.h:41215
Type
Definition: hps.h:428
HPS::Type ObjectType() const
Definition: hps.h:21260
friend bool operator!=(wchar_t const *in_left, UTF8 const &in_right)
Definition: hps.h:7002
PixelPoint(Point const &in_point)
Definition: hps.h:6106
HPS::Type ObjectType() const
Definition: hps.h:6228
HPS::Type ObjectType() const
Definition: hps.h:7091
Definition: hps.h:17880
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:41901
Definition: hps.h:21102
Definition: hps.h:44021
size_t non_display_list_tristrip_count
Number of tristrips drawn during the last update.
Definition: hps.h:4822
HPS::Type ObjectType() const
Definition: hps.h:21865
size_t display_list_vertex_3d_count
Number of vertices drawn from display lists during the last update.
Definition: hps.h:4820
HPS::Type ObjectType() const
Definition: hps.h:21744
Percentage of the requested font size defining the lower limit on the smallest font size that can be ...
HPS::Type ObjectType() const
Definition: hps.h:35458
HPS::Type ObjectType() const
Definition: hps.h:28967
HPS::Type ObjectType() const
Definition: hps.h:24330
HPS::Type ObjectType() const
Definition: hps.h:39403
HPS::Type ObjectType() const
Definition: hps.h:21125
HPS::MouseEvent::Action CurrentAction
The action for this MouseEvent.
Definition: hps.h:41921
Event * Clone() const
Definition: hps.h:41305
Definition: hps.h:14453
bool operator==(GlyphPoint const &in_that) const
Definition: hps.h:5084
Definition: hps.h:36091
Definition: hps.h:41236
HPS::Type ObjectType() const
Definition: hps.h:34766
HPS::Type ObjectType() const
Definition: hps.h:40780
Alignment and justification will be defined relative to a screen-facing box around the text...
Definition: hps.h:43629
HPS::Type ObjectType() const
Definition: hps.h:15947
Definition: hps.h:1919
Definition: hps.h:31423
Infinite line which extends infinitely in both directions along a vector.
size_t line_3d_count
Number of 3D lines drawn during the last update.
Definition: hps.h:4811
InformationEvent(char const *in_message, HPS::Info::Code in_code)
Definition: hps.h:40940
intptr_t GetChannel() const
Definition: hps.h:6182
HPS::Type ObjectType() const
Definition: hps.h:9382
Definition: hps.h:1344
Definition: hps.h:13754
Algorithm
Definition: hps.h:1358
Definition: hps.h:43003
HPS::Type ObjectType() const
Definition: hps.h:31445
Definition: hps.h:43203
HPS::Type ObjectType() const
Definition: hps.h:38118
HPS_INLINE bool Intersecting(Cuboid_3D const &cuboid, F const allowance) const
Definition: hps.h:3859
Definition: hps.h:12657
Definition: hps.h:42777
Definition: hps.h:10792
Driver
Definition: hps.h:44322
Definition: hps.h:7043
Definition: hps.h:42369
SizeUnits
Definition: hps.h:1684
StandAloneWindowEvent()
Definition: hps.h:41155
HPS::Type ObjectType() const
Definition: hps.h:36644
HPS::Type ObjectType() const
Definition: hps.h:34604
ModifierKeys GetModifierKeys() const
Definition: hps.h:41506
Definition: hps.h:41315
Definition: hps.h:39732
Definition: hps.h:40998
HPS::Type ObjectType() const
Definition: hps.h:12517
HPS::Type ObjectType() const
Definition: hps.h:11337
Definition: hps.h:43190
virtual bool Equals(WarningEvent const &in_that) const
Definition: hps.h:41042
MouseEvent(Action in_action, WindowPoint in_location, MouseButtons in_button=MouseButtons(), ModifierKeys in_modifier=ModifierKeys(), size_t in_click_count=0)
Definition: hps.h:41829
An InvalidObjectException is thrown when a user tries to interact with an object that either is unini...
Definition: hps.h:5539
HPS::Type ObjectType() const
Definition: hps.h:17613
Level
Definition: hps.h:1349
virtual bool Equals(InformationEvent const &in_that) const
Definition: hps.h:40971
bool X2() const
Definition: hps.h:41702
bool Equals(ModifierKeys const &in_that) const
Definition: hps.h:41324
Definition: hps.h:34582
Definition: hps.h:44689
bool Left() const
Definition: hps.h:41686
void Control(bool in_state)
Definition: hps.h:41383
Definition: hps.h:21833
Definition: hps.h:2909
Definition: hps.h:17162
Definition: hps.h:41459
HPS::Type ObjectType() const
Definition: hps.h:44049
HPS::Type ObjectType() const
Definition: hps.h:18327
HPS_INLINE bool Contains(Point_3D< F > const &contained) const
Definition: hps.h:4006
UTF8 message
The warning message for this WarningEvent.
Definition: hps.h:41063
The base class of all HPS exceptions.
Definition: hps.h:5531
RegionAlignment
Definition: hps.h:1663
TouchEvent(Action in_action, size_t in_touch_count, Touch const in_touches[], ModifierKeys in_modifier=ModifierKeys())
Definition: hps.h:41551
Event * Clone() const
Definition: hps.h:41866
Definition: hps.h:6149
HPS::Type ObjectType() const
Definition: hps.h:21409
Definition: hps.h:37574
InformationEvent(Event const &in_event)
Definition: hps.h:40944
Definition: hps.h:12934
void Invalidate()
Definition: hps.h:3804
Definition: hps.h:23230
Definition: hps.h:39101
Quaternion Spline(Quaternion const &in_previous, Quaternion const &in_next) const
Definition: hps.h:4798
IOException(char const *in_info, IOResult in_result)
Definition: hps.h:5590
UpdateCompletedEvent(Time in_update_time)
Definition: hps.h:41243
HPS::Type ObjectType() const
Definition: hps.h:34092
Definition: hps.h:43270
Definition: hps.h:6099
HPS::Type ObjectType() const
Definition: hps.h:40000
HPS::ByteArray non_db_user_data
Definition: hps.h:42480
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:6175
Definition: hps.h:403
char const * GetBytes() const
Definition: hps.h:6888
virtual intptr_t Freshen() const
Definition: hps.h:41913
Definition: hps.h:34463
HPS::Type ObjectType() const
Definition: hps.h:35599
InputEvent(ModifierKeys const &in_modifiers)
Definition: hps.h:41468
float green
Definition: hps.h:4301
Action
Definition: hps.h:41810
The vertex colors applied to faces.
SizeUnits
Definition: hps.h:1708
HPS::Type ObjectType() const
Definition: hps.h:10419
HPS::Type ObjectType() const
Definition: hps.h:27356
HPS::Type ObjectType() const
Definition: hps.h:24848
size_t triangle_dc_count
Number of DC triangles drawn during the last update.
Definition: hps.h:4812
HPS::Type ObjectType() const
Definition: hps.h:24604
static void * Allocate(size_t in_bytes, bool in_clear_memory=true)
Definition: hps.h:10618
HPS::Type ObjectType() const
Definition: hps.h:38170
HPS::Type ObjectType() const
Definition: hps.h:24969
InnerPixelPoint(Point const &in_point)
Definition: hps.h:6007
ImportStatusEvent(Event const &in_event)
Definition: hps.h:41290
NormalizedPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5857
Touch(TouchID in_id, WindowPoint const &in_location, size_t in_tap_count=1)
Definition: hps.h:6447
Definition: hps.h:42571
static const float NegativeInfinity
Definition: hps.h:2202
Definition: hps.h:42662
HighlightEvent(Event const &in_event)
Definition: hps.h:40898
friend bool operator==(wchar_t const *in_left, UTF8 const &in_right)
Definition: hps.h:6993
SizeUnits
Definition: hps.h:1489
HPS::Type ObjectType() const
Definition: hps.h:12958
HPS::Type ObjectType() const
Definition: hps.h:20819
Definition: hps.h:21505
HPS::MouseButtons CurrentButton
If the action involves a button, this is the button.
Definition: hps.h:41923
HPS::Type ObjectType() const
Definition: hps.h:10640
InnerWindowPoint(Point const &in_point)
Definition: hps.h:5958
GatheringLevel
Definition: hps.h:1764
HPS::Type ObjectType() const
Definition: hps.h:29177
HPS::Info::Code code
The warning code for this InformationEvent.
Definition: hps.h:40993
Definition: hps.h:40753
Cuboid_3D(size_t count, Point_3D< F > const *points)
Definition: hps.h:3771
Definition: hps.h:12552
FrameOptions
Definition: hps.h:214
HPS::Type ObjectType() const
Definition: hps.h:35408
Space
Definition: hps.h:8606
void Alt(bool in_state)
Definition: hps.h:41387
Definition: hps.h:7052
Buttons
Definition: hps.h:41790
KeyboardEvent(KeyboardEvent::Action in_action, ModifierKeys in_modifiers=ModifierKeys())
Definition: hps.h:41948
HPS::Type ObjectType() const
Definition: hps.h:37374
Type
Definition: hps.h:258
bool operator!=(Touch const &in_that) const
Definition: hps.h:6461
Definition: hps.h:40366
Definition: hps.h:24225
Definition: hps.h:99
Type
Definition: hps.h:446
HPS::Type ObjectType() const
Definition: hps.h:43516
HPS::Type ObjectType() const
Definition: hps.h:44898
HPS::Type ObjectType() const
Definition: hps.h:44787
HPS::Type ObjectType() const
Definition: hps.h:33823
WorldPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5757
HPS::Type ObjectType() const
Definition: hps.h:9574
HPS::Type ObjectType() const
Definition: hps.h:44984
friend bool operator==(char const *in_left, UTF8 const &in_right)
Definition: hps.h:6975
Definition: hps.h:23490
HPS::SegmentKey & segment_key
Definition: hps.h:42522
Definition: hps.h:42484
Definition: hps.h:35293
Definition: hps.h:1271
Event * Clone() const
Definition: hps.h:41576
void Middle(bool in_state)
Definition: hps.h:41725
Definition: hps.h:29155
virtual bool Equals(ErrorEvent const &in_that) const
Definition: hps.h:41113
Definition: hps.h:4806
Event * Clone() const
Definition: hps.h:41181
Definition: hps.h:43297
size_t GetLength() const
Definition: hps.h:6873
HPS::Type ObjectType() const
Definition: hps.h:21212
HPS::Type ObjectType() const
Definition: hps.h:26914
Type
Definition: hps.h:1134
Definition: hps.h:423
HPS::Type ObjectType() const
Definition: hps.h:9490
bool None() const
Definition: hps.h:41347
size_t ClickCount
The number of clicks received.
Definition: hps.h:41925
virtual intptr_t Freshen() const
Definition: hps.h:6179
void Reset()
Definition: hps.h:6868
HPS::Type ObjectType() const
Definition: hps.h:37904
HPS::Type ObjectType() const
Definition: hps.h:23985
Definition: hps.h:34336
HPS::Type ObjectType() const
Definition: hps.h:40104
Definition: hps.h:39380
Definition: hps.h:43464
SizeUnits
Definition: hps.h:1617
Event * Clone() const
Definition: hps.h:41104
MouseEvent(Event const &in_event)
Definition: hps.h:41844
bool Right() const
Definition: hps.h:41690
Definition: hps.h:2024
virtual bool Empty() const
Definition: hps.h:5633
Join
Definition: hps.h:1839
HPS_INLINE void Merge(Sphere_3D< F > const &sphere)
Definition: hps.h:3928
Modifier
Definition: hps.h:1876
static MouseButtons ButtonLeft()
Definition: hps.h:41768
size_t dot_dc_count
Number of DC dots drawn during the last update.
Definition: hps.h:4808
static MouseButtons ButtonMiddle()
Definition: hps.h:41776
TouchEvent(Action in_action, ModifierKeys in_modifier=ModifierKeys())
Definition: hps.h:41534
static intptr_t ClassID()
Definition: hps.h:5655
HighlightEvent()
Definition: hps.h:40882
virtual HPS::Type ObjectType() const
Definition: hps.h:5629
Definition: hps.h:42597
Definition: hps.h:19033
HPS::Type ObjectType() const
Definition: hps.h:13972
Definition: hps.h:28807
Definition: hps.h:16870
Definition: hps.h:5852
HPS::TouchEvent::Action CurrentAction
The action for the touches of this TouchEvent.
Definition: hps.h:41633
Definition: hps.h:8744
Type
Definition: hps.h:581
virtual intptr_t Freshen() const
Definition: hps.h:40865
Background
Definition: hps.h:239
HPS_INLINE bool Intersecting(Cuboid_3D const &cuboid) const
Definition: hps.h:3848
Definition: hps.h:44181
static ModifierKeys KeyControl()
Definition: hps.h:41430
HPS::Type ObjectType() const
Definition: hps.h:18541
Definition: hps.h:5549
HPS::Type ObjectType() const
Definition: hps.h:35854
Definition: hps.h:7346
ScreenRangePoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5905
Definition: hps.h:43123
HPS::Type ObjectType() const
Definition: hps.h:39896
StandAloneWindowEvent(Action in_action)
Definition: hps.h:41160
Mode
Definition: hps.h:1729
Definition: hps.h:33462
size_t segment_count
Number of segments traversed during the last update.
Definition: hps.h:4825
Definition: hps.h:11314
UTF8 message
The warning information for this WarningEvent.
Definition: hps.h:40992
Event * Clone() const
Definition: hps.h:41264
Definition: hps.h:34198
size_t polygon_3d_count
Number of 3D polygons drawn during the last update.
Definition: hps.h:4815
HPS_INLINE Cuboid_3D & Expand(F border)
Definition: hps.h:4065
HPS_INLINE bool Intersecting(int dimension, Cuboid_3D const &cuboid, F const allowance) const
Definition: hps.h:3883
Definition: hps.h:34060
size_t display_list_triangle_3d_count
Number of triangles drawn from display lists during the last update.
Definition: hps.h:4819
Type
Definition: hps.h:884
Definition: hps.h:346
Definition: hps.h:14892
Definition: hps.h:21580
HPS_INLINE Vector_3D< F > Diagonal() const
Definition: hps.h:3836
Definition: hps.h:919
HPS::Type ObjectType() const
Definition: hps.h:12426
Definition: hps.h:36036
HPS::Type ObjectType() const
Definition: hps.h:32522
HPS::Type ObjectType() const
Definition: hps.h:18008
Definition: hps.h:42421
HPS::Type ObjectType() const
Definition: hps.h:38002
Definition: hps.h:35710
HPS::Type ObjectType() const
Definition: hps.h:43651
Definition: hps.h:5901
HPS::Type ObjectType() const
Definition: hps.h:42281
HPS_INLINE void Generate_Cuboid_Points(Point_3D< F > *points) const
Definition: hps.h:3822
HPS::Type ObjectType() const
Definition: hps.h:37157
Definition: hps.h:35975
HPS::Type ObjectType() const
Definition: hps.h:12576
HPS::Type ObjectType() const
Definition: hps.h:18082
Definition: hps.h:24308
Mode
Definition: hps.h:1782
Definition: hps.h:8958
Event * Clone() const
Definition: hps.h:41995
Definition: hps.h:10395
HPS_INLINE bool Intersecting(Point_3D< F > const &start, Vector_3D< F > const &direction) const
Definition: hps.h:3894
Tiling
Definition: hps.h:987
HPS_INLINE Cuboid_3D & Union(Cuboid_3D const &cuboid)
Definition: hps.h:4050
WindowPoint(Point const &in_point)
Definition: hps.h:6057
Transform
Definition: hps.h:1572
HPS::Type ObjectType() const
Definition: hps.h:37472
Definition: hps.h:11575
Definition: hps.h:8688
HPS::Key & key
Definition: hps.h:42508
Definition: hps.h:40927
A unitless linear scaling factor. A value of 2.0 will cause edges to be rendered twice as thick...
Definition: hps.h:22189
Definition: hps.h:35426
Definition: hps.h:27669
Definition: hps.h:22474
Grid composed of quadrilaterals.
HPS::Type ObjectType() const
Definition: hps.h:38829
Definition: hps.h:26178
Definition: hps.h:939
ModifierKeys()
Definition: hps.h:41319
Definition: hps.h:25219
Definition: hps.h:1811
Definition: hps.h:22832
Definition: hps.h:28281
Definition: hps.h:42498
Preference
Definition: hps.h:1597
HPS::Type ObjectType() const
Definition: hps.h:25521
Capping
Definition: hps.h:526
Definition: hps.h:41069
HPS::Type ObjectType() const
Definition: hps.h:35672
TouchEvent()
Definition: hps.h:41528
Interpolation
Definition: hps.h:1003
HPS::Type ObjectType() const
Definition: hps.h:20191
virtual bool Equals(InputEvent const &in_that) const
Definition: hps.h:41483
WarningEvent(char const *in_message)
Definition: hps.h:41006
HPS::Type ObjectType() const
Definition: hps.h:20987
Modifiers
Definition: hps.h:41444
Component
Definition: hps.h:518
Definition: hps.h:513
Definition: hps.h:9990
Definition: hps.h:37778
HPS::Type ObjectType() const
Definition: hps.h:36162
HPS::Type ObjectType() const
Definition: hps.h:6564
HPS::Type ObjectType() const
Definition: hps.h:22768
Definition: hps.h:17589
HPS_INLINE Cuboid_3D & Intersect(Cuboid_3D const &cuboid)
Definition: hps.h:4035
HPS::Type ObjectType() const
Definition: hps.h:44208
HPS::Type ObjectType() const
Definition: hps.h:22558
Definition: hps.h:3195
Format
Definition: hps.h:37335
WarningEvent()
Definition: hps.h:41002
Definition: hps.h:25135
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:40859
Touch()
Definition: hps.h:6441
Definition: hps.h:12344
Definition: hps.h:36129
size_t polyhedron_count
Number of polyhedra drawn during the last update.
Definition: hps.h:4816
Component
Definition: hps.h:408
Definition: hps.h:33807
A unitless linear scaling factor. A value of 2.0 will cause lines to be rendered twice as thick...
Definition: hps.h:39873
Definition: hps.h:1129
float red
Definition: hps.h:4300
ClipSpace
Definition: hps.h:1313
Definition: hps.h:12256
Definition: hps.h:37969
Definition: hps.h:15924
Control & operator=(Control &&in_that)
Definition: hps.h:5692
Definition: hps.h:42882
WarningEvent(char const *in_message, HPS::Info::Code in_code)
Definition: hps.h:41011
HPS::Type ObjectType() const
Definition: hps.h:14077
Definition: hps.h:29076
SizeUnits
Definition: hps.h:44165
void Right(bool in_state)
Definition: hps.h:41721
virtual void Reset()
Definition: hps.h:40803
Definition: hps.h:11901
Definition: hps.h:43420
HPS::Type ObjectType() const
Definition: hps.h:11454
bool Meta() const
Definition: hps.h:41363
HPS_INLINE Cuboid_3D & Contract(F border)
Definition: hps.h:4077
Definition: hps.h:35638
TimerTickEvent()
Definition: hps.h:40831
Definition: hps.h:38636
Definition: hps.h:37352
HPS::Type ObjectType() const
Definition: hps.h:22221
RenderingAlgorithm
Definition: hps.h:275
EmergencyHandler()
Definition: hps.h:40343
CameraPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5807
TouchID ID
TouchID for this Touch.
Definition: hps.h:6466
Definition: hps.h:36611
HPS::Type ObjectType() const
Definition: hps.h:11017
HPS::Type ObjectType() const
Definition: hps.h:33484
HPS::Type ObjectType() const
Definition: hps.h:8469
Definition: hps.h:44160
Definition: hps.h:6205
Definition: hps.h:24582
HandednessOptimization
Definition: hps.h:369
Definition: hps.h:6747
size_t raster_count
Number of rasters drawn during the last update.
Definition: hps.h:4824
size_t deleted_display_list_count
Number of deleted display lists during the last update.
Definition: hps.h:4817
Projection
Definition: hps.h:1407
Control(Control &&in_that)
Definition: hps.h:5687
bool Control() const
Definition: hps.h:41355
Definition: hps.h:5456
HPS::Type ObjectType() const
Definition: hps.h:35007
HPS::Type ObjectType() const OVERRIDE
Definition: hps.h:8721
Overlay
Definition: hps.h:1285
Definition: hps.h:28945
Definition: hps.h:5999
Definition: hps.h:37450
Definition: hps.h:44466
size_t GetHash() const
Status
Definition: hps.h:6155
Definition: hps.h:22315
HPS::Type ObjectType() const
Definition: hps.h:35137
HPS::Type ObjectType() const
Definition: hps.h:6646
float WheelDelta
If the action involves the mouse wheel, this is the amount the wheel moved. It is positive if the mou...
Definition: hps.h:41924
Definition: hps.h:37619
Definition: hps.h:43494
Definition: hps.h:27252
Definition: hps.h:2040
HPS::Type ObjectType() const
Definition: hps.h:42391