API Search || Global Search
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 namespace HPSI
76 {
77  class Impl;
78  class KeyImpl;
79  class TicketImpl;
80  class EventDispatcherImpl;
81  class AbstractImage;
82  class String;
83 };
84 
85 namespace HPS
86 {
87 
88  // unimplemented
89 
90 
91 //Begin Info
93 class HPS_API Info
94 {
95 public:
96 
99  enum class Code : uint32_t
100  {
101  Unknown,
102  Exchange,
103  Publish,
104  Data,
105  Key,
106  Geometry,
107  Database,
108  Driver,
109  Internal,
110  Memory,
111  System,
112  Unsupported,
113  DX9DeviceReset,
114  DWG,
115  Parasolid,
116  };
117 
118 private:
119  Info() {}
120 };
121 
122 
123 //Begin Info
125 class HPS_API Emergency
126 {
127 public:
128 
131  enum class Code : uint32_t
132  {
133  Unknown,
134  Fatal,
135  SoftMemoryLimit,
136  HardMemoryLimit,
137  };
138 
139 private:
140  Emergency() {}
141 };
142 
143 
144 //Begin Window
146 class HPS_API Window
147 {
148 public:
149 
154  enum class Driver : uint32_t
155  {
156  Default3D,
157  OpenGL,
158  OpenGL2,
159  DirectX9,
160  DirectX11,
161  OpenGL1Deprecated,
162  Vulkan,
163  Metal,
164  };
165 
168  enum class UpdateStatus : uint32_t
169  {
170  InProgress,
171  Completed,
172  TimedOut,
173  Interrupted,
174  Failed
175  };
176 
180  enum class UpdateType : uint32_t
181  {
183  Default,
184 
189  Complete,
190 
192  Refresh,
193 
195  CompileOnly,
196 
200  Exhaustive,
201  };
202 
205  enum class Mobility : uint32_t
206  {
207  Locked,
208  Floating,
209  FixedRatio,
210  Free
211  };
212 
215  enum class FrameSize : uint32_t
216  {
217  Single,
218  Double
219  };
220 
223  enum class FrameOptions : uint32_t
224  {
225  Inset,
226  Overlay
227  };
228 
231  enum class ImageFormat : uint32_t
232  {
233  Default,
234  RGBA,
235  RGB,
236  Jpeg,
237  Png
238  };
239 
240 private:
241  Window() {}
242 };
243 
244 //Begin Subwindow
246 class HPS_API Subwindow
247 {
248 public:
249  enum class Background : uint32_t
250  {
251  SolidColor,
252  Image,
253  Cubemap,
254  Blend,
255  Transparent,
256  Interactive,
257 
258  GradientTopToBottom,
259  GradientBottomToTop,
260  GradientLeftToRight,
261  GradientRightToLeft,
262  GradientTopLeftToBottomRight,
263  GradientTopRightToBottomLeft,
264  GradientBottomLeftToTopRight,
265  GradientBottomRightToTopLeft,
266  };
267 
268  enum class Type : uint32_t
269  {
270  Standard,
271  Lightweight
272  };
273 
274  enum class Border : uint32_t
275  {
276  None,
277  Inset,
278  InsetBold,
279  Overlay,
280  OverlayBold
281  };
282 
283 
285  enum class RenderingAlgorithm : uint32_t
286  {
289  ZBuffer,
290 
296  HiddenLine,
297 
303  FastHiddenLine,
304 
317  Priority
318  };
319 
320 private:
321  Subwindow() {}
322 };
323 //End Subwindow
324 
326 class HPS_API Style
327 {
328 public:
329 
332  enum class Type : uint32_t
333  {
334  Segment,
335  Named
336  };
337 
340  enum class AppendMode : uint32_t
341  {
342  None,
343  And,
344  Or
345  };
346 
347 private:
348  Style() {}
349 };
350 
351 
353 class HPS_API Shell
354 {
355 public:
356 
359  enum class Component : uint32_t
360  {
361  Faces,
362  Edges,
363  Vertices
364  };
365 
366  /* \enum ToleranceUnits
367  * Enumerates the Tolerance Units used to determine if points can be merged during shell optimization. */
368  enum class ToleranceUnits : uint32_t
369  {
370  ObjectSpace,
371  FeatureSizePercentage
372  };
373 
374  /* \enum HandednessOptimization
375  * Enumerates the shell optimization options with regards to handedness. */
376  enum class HandednessOptimization : uint32_t
377  {
378  None,
379  Fix,
380  Reverse
381  };
382 
383  /* \enum RelationResults
384  * Enumerates the results of a shell relation computation. */
385  enum class Relation : uint32_t
386  {
387  On,
388  Off,
389  In,
390  Out
391  };
392 
393  /* \enum RelationTest
394  * Enumerates the test options for a shell relation computation. */
395  enum class RelationTest : uint32_t
396  {
397  Simple,
398  Enclosure,
399  Distance
400  };
401 
402 private:
403  Shell() {}
404 };
405 
406 
408 class HPS_API Mesh
409 {
410 public:
411 
414  enum class Component : uint32_t
415  {
416  Faces,
417  Edges,
418  Vertices
419  };
420 
421 private:
422  Mesh() {}
423 };
424 
425 
427 class HPS_API InfiniteLine
428 {
429 public:
430 
433  enum class Type : uint32_t
434  {
435  Line,
436  Ray
437  };
438 
439 private:
440  InfiniteLine() {}
441 };
442 
443 
445 class HPS_API Trim
446 {
447 public:
448 
451  enum class Type : uint32_t
452  {
453  Line,
454  Curve
455  };
456 
460  enum class Operation : uint32_t
461  {
462  Keep,
463  Remove
464  };
465 
466 private:
467  Trim() {}
468 };
469 
470 
472 class HPS_API Spotlight
473 {
474 public:
475 
478  enum class OuterConeUnits : uint32_t
479  {
483  Degrees,
487  FieldRadius
488  };
489 
492  enum class InnerConeUnits : uint32_t
493  {
497  Degrees,
501  FieldRadius,
504  Percent
505  };
506 
507 private:
508  Spotlight() {}
509 };
510 
511 
513 class HPS_API Cylinder
514 {
515 public:
516 
519  enum class Component : uint32_t
520  {
521  Faces,
522  Edges,
523  };
524 
527  enum class Capping : uint32_t
528  {
529  None,
530  First,
531  Last,
532  Both
533  };
534 
537  enum class Orientation : uint32_t
538  {
539  Default,
540  DefaultRadii,
541  InvertRadii,
542  InvertRadiiOnly,
543  DefaultColors,
544  InvertColors,
545  InvertColorsOnly,
546  InvertAll
547  };
548 
549 private:
550  Cylinder() {}
551 };
552 
553 
555 class HPS_API HighlightSearch
556 {
557 public:
558 
561  enum class Scope : uint32_t
562  {
563  AtOrAbovePath,
564  AtOrBelowPath,
565  ExactPath
566  };
567 
568 private:
569  HighlightSearch() {}
570 };
571 
573 class HPS_API Search
574 {
575 public:
576 
579  enum class Space : uint32_t
580  {
581  SegmentOnly,
582  Subsegments,
583  SubsegmentsAndIncludes
584  };
585 
588  enum class Behavior : uint32_t
589  {
590  Exhaustive,
591  FirstMatch
592  };
593 
596  enum class Type : uint32_t
597  {
598  None = 0x00000000,
599  Everything = 0x00ffffff,
600 
601  Include = 0x00000042,
602  Segment = 0x00000043,
603 
604  Includer = 0x00000100,
605 
606  // Geometry
607  Geometry = 0x10000000,
608 
609  CuttingSection = 0x10000026,
610  Shell = 0x10000028,
611  Mesh = 0x10000029,
612  Grid = 0x1000002a,
613  NURBSSurface = 0x1000002b,
614  Cylinder = 0x1000002d,
615  Sphere = 0x1000002e,
616  Polygon = 0x1000002f,
617  Circle = 0x10000030,
618  //unused = 0x10000031,
619  CircularWedge = 0x10000032,
620  Ellipse = 0x10000033,
621  Line = 0x10000034,
622  NURBSCurve = 0x10000037,
623  CircularArc = 0x10000038,
624  EllipticalArc = 0x10000039,
625  InfiniteLine = 0x1000003a,
626  //unused = 0x1000003b,
627  Marker = 0x1000003c,
628  Text = 0x1000003e,
629  Reference = 0x10000041,
630 
631  DistantLight = 0x10000100,
632  Spotlight = 0x10000101,
633  InfiniteRay = 0x10000102,
634 
635  // Attributes
636  Attribute = 0x20000000,
637 
638  Priority = 0x20000001,
639 
640  // Simple Attributes
641  Material = 0x2000000b,
642  PBRMaterial = 0x2000000c,
643  Camera = 0x2000000f,
644  ModellingMatrix = 0x20000011,
645  UserData = 0x20000022,
646  TextureMatrix = 0x20000024,
647 
648  // Complex Attributes
649  Culling = 0x20001000,
650  CullingBackFace = 0x20001001,
651  CullingExtent = 0x20001002,
652  CullingVector = 0x20001003,
653  CullingVectorTolerance = 0x20001004,
654  CullingFrustum = 0x20001005,
655  CullingDeferralExtent = 0x20001006,
656  CullingVolume = 0x20001007,
657  CullingDistance = 0x20001008,
658 
659  CurveAttribute = 0x20002000,
660  CurveAttributeBudget = 0x20002001,
661  CurveAttributeContinuedBudget = 0x20002002,
662  CurveAttributeViewDependent = 0x20002003,
663  CurveAttributeMaximumDeviation = 0x20002004,
664  CurveAttributeMaximumAngle = 0x20002005,
665  CurveAttributeMaximumLength = 0x20002006,
666 
667  CylinderAttribute = 0x20003000,
668  CylinderAttributeTessellation = 0x20003001,
669  CylinderAttributeOrientation = 0x20003002,
670 
671  EdgeAttribute = 0x20004000,
672  EdgeAttributePattern = 0x20004016,
673  EdgeAttributeWeight = 0x20004017,
674  EdgeAttributeHardAngle = 0x20004018,
675 
676  LightingAttribute = 0x20005000,
677  LightingAttributeInterpolation = 0x20005001,
678 
679  LineAttribute = 0x20006000,
680  LineAttributePattern = 0x2000601a,
681  LineAttributeWeight = 0x2000601b,
682 
683  MarkerAttribute = 0x20007000,
684  MarkerAttributeGlyphRotation = 0x2000701a,
685  MarkerAttributeSize = 0x2000701c,
686  MarkerAttributeSymbol = 0x2000701d,
687  MarkerAttributePreference = 0x2000701e,
688 
689  SurfaceAttribute = 0x20008000,
690  SurfaceAttributeBudget = 0x20008001,
691  SurfaceAttributeMaximumFacetDeviation = 0x20008002,
692  SurfaceAttributeMaximumFacetAngle = 0x20008003,
693  SurfaceAttributeMaximumFacetWidth = 0x20008004,
694  SurfaceAttributeTrimCurveBudget = 0x20008005,
695  SurfaceAttributeMaximumTrimCurveDeviation = 0x20008006,
696 
697  Selectability = 0x20009000,
698  SelectabilityWindows = 0x20009001,
699  SelectabilityEdges = 0x20009002,
700  SelectabilityFaces = 0x20009003,
701  SelectabilityLights = 0x20009004,
702  SelectabilityLines = 0x20009005,
703  SelectabilityMarkers = 0x20009006,
704  SelectabilityVertices = 0x20009007,
705  SelectabilityText = 0x20009008,
706 
707  SphereAttribute = 0x2000a000,
708  SphereAttributeTessellation = 0x2000a001,
709 
710  Subwindow = 0x2000b000,
711  SubwindowEitherType = 0x2000b001,
712  SubwindowStandard = 0x2000b00e,
713  SubwindowLightweight = 0x2000b002,
714  SubwindowBackground = 0x2000b003,
715  SubwindowBorder = 0x2000b004,
716  SubwindowRenderingAlgorithm = 0x2000b005,
717 
718  TextAttribute = 0x2000c000,
719  TextAttributeAlignment = 0x2000c01e,
720  TextAttributeBold = 0x2000c002,
721  TextAttributeItalic = 0x2000c003,
722  TextAttributeOverline = 0x2000c004,
723  TextAttributeStrikethrough = 0x2000c005,
724  TextAttributeUnderline = 0x2000c006,
725  TextAttributeSlant = 0x2000c007,
726  TextAttributeLineSpacing = 0x2000c008,
727  TextAttributeRotation = 0x2000c00a,
728  TextAttributeExtraSpace = 0x2000c00b,
729  TextAttributeGreeking = 0x2000c00c,
730  TextAttributeSizeTolerance = 0x2000c00d,
731  TextAttributeSize = 0x2000c00e,
732  TextAttributeFont = 0x2000c00f,
733  TextAttributeTransform = 0x2000c010,
734  TextAttributeRenderer = 0x2000c011,
735  TextAttributePreference = 0x2000c012,
736  TextAttributePath = 0x2000c020,
737  TextAttributeSpacing = 0x2000c021,
738  TextAttributeBackground = 0x2000c022,
739  TextAttributeBackgroundMargins = 0x2000c023,
740  TextAttributeBackgroundStyle = 0x2000c024,
741  TextAttributeLeaderLine = 0x2000c025,
742 
743  Transparency = 0x2000d000,
744  TransparencyMethod = 0x2000d001,
745  TransparencyAlgorithm = 0x2000d002,
746  TransparencyDepthPeelingLayers = 0x2000d004,
747  TransparencyDepthPeelingMinimumArea = 0x2000d005,
748  TransparencyDepthWriting = 0x2000d006,
749 
750  Visibility = 0x2000e000,
751  VisibilityCuttingSections = 0x2000e001,
752  VisibilityCutEdges = 0x2000e002,
753  VisibilityCutFaces = 0x2000e003,
754  VisibilityWindows = 0x2000e004,
755  VisibilityText = 0x2000e005,
756  VisibilityLines = 0x2000e006,
757  VisibilityEdgeLights = 0x2000e007,
758  VisibilityMarkerLights = 0x2000e008,
759  VisibilityFaceLights = 0x2000e009,
760  VisibilityGenericEdges = 0x2000e00a,
761  VisibilityHardEdges = 0x2000e00b,
762  VisibilityAdjacentEdges = 0x2000e00c,
763  VisibilityInteriorSilhouetteEdges = 0x2000e00d,
764  VisibilityShadowEmitting = 0x2000e00e,
765  VisibilityShadowReceiving = 0x2000e00f,
766  VisibilityShadowCasting = 0x2000e010,
767  VisibilityMarkers = 0x2000e011,
768  VisibilityVertices = 0x2000e012,
769  VisibilityFaces = 0x2000e013,
770  VisibilityPerimeterEdges = 0x2000e014,
771  VisibilityNonCulledEdges = 0x2000e015,
772  VisibilityMeshQuadEdges = 0x2000e016,
773  VisibilityEdges = 0x2000e017,
774  VisibilityLeaderLines = 0x2000e018,
775 
776  VisualEffects = 0x2000f000,
777  VisualEffectsPostProcessEffectsEnabled = 0x2000f001,
778  VisualEffectsAntiAliasing = 0x2000f002,
779  VisualEffectsShadowMaps = 0x2000f003,
780  VisualEffectsSimpleShadow = 0x2000f004,
781  VisualEffectsSimpleShadowPlane = 0x2000f005,
782  VisualEffectsSimpleShadowLightDirection = 0x2000f006,
783  VisualEffectsSimpleShadowColor = 0x2000f007,
784  VisualEffectsSimpleReflection = 0x2000f008,
785  VisualEffectsSimpleReflectionPlane = 0x2000f009,
786  VisualEffectsSimpleReflectionVisibility = 0x2000f00a,
787  VisualEffectsEyeDomeLightingBackColor = 0x2000f00b,
788 
789  Performance = 0x20010000,
790  PerformanceDisplayLists = 0x20010001,
791  PerformanceStaticModel = 0x20010002,
792  StaticModelSegment = 0x40000043,
793 
794  DrawingAttribute = 0x20011000,
795  DrawingAttributePolygonHandedness = 0x20011001,
796  DrawingAttributeDepthRange = 0x20011002,
797  DrawingAttributeFaceDisplacement = 0x20011003,
798  DrawingAttributeGeneralDisplacement = 0x20011004,
799  DrawingAttributeVertexDisplacement = 0x20011005,
800  DrawingAttributeOverlay = 0x20011006,
801  DrawingAttributeDeferral = 0x20011007,
802  DrawingAttributeVertexDecimation = 0x20011008,
803  DrawingAttributeVertexRandomization = 0x20011009,
804  DrawingAttributeOverrideInternalColor = 0x2001100a,
805  DrawingAttributeClipRegion = 0x20011013,
806  DrawingAttributeWorldHandedness = 0x20011019,
807 
808 
809  HiddenLineAttribute = 0x20012000,
810  HiddenLineAttributeAlgorithm = 0x20012001,
811  HiddenLineAttributeColor = 0x20012002,
812  HiddenLineAttributeDimFactor = 0x20012003,
813  HiddenLineAttributeFaceDisplacement = 0x20012004,
814  HiddenLineAttributeLinePattern = 0x20012005,
815  HiddenLineAttributeLineSort = 0x20012006,
816  HiddenLineAttributeRenderFaces = 0x20012007,
817  HiddenLineAttributeRenderText = 0x20012008,
818  HiddenLineAttributeSilhouetteCleanup = 0x20012009,
819  HiddenLineAttributeTransparencyCutoff = 0x2001200a,
820  HiddenLineAttributeVisibility = 0x2001200b,
821  HiddenLineAttributeWeight = 0x2001200c,
822 
823 
824  SegmentStyle = 0x20013001,
825  NamedStyle = 0x20013002,
826  MaterialPalette = 0x20013003,
827  Portfolio = 0x20013004,
828 
829  ContourLine = 0x20014000,
830  ContourLineVisibility = 0x20014001,
831  ContourLinePosition = 0x20014002,
832  ContourLineColor = 0x20014003,
833  ContourLinePattern = 0x20014004,
834  ContourLineWeight = 0x20014005,
835  ContourLineLighting = 0x20014006,
836 
837  Condition = 0x20015000,
838 
839  Bounding = 0x20016000,
840  BoundingVolume = 0x20016001,
841  BoundingExclusion = 0x20016002,
842 
843  AttributeLock = 0x20017000,
844  AttributeLockSetting = 0x20017001,
845  AttributeLockSubsegmentOverride = 0x20017002,
846 
847  TransformMask = 0x20018000,
848  TransformMaskCamera = 0x20018001,
849  TransformMaskCameraTranslation = 0x20018002,
850  TransformMaskCameraScale = 0x20018003,
851  TransformMaskCameraOffset = 0x20018004,
852  TransformMaskCameraRotation = 0x20018005,
853  TransformMaskCameraPerspectiveScale = 0x20018006,
854  TransformMaskCameraProjection = 0x20018007,
855  TransformMaskModellingMatrix = 0x20018008,
856  TransformMaskModellingMatrixTranslation = 0x20018009,
857  TransformMaskModellingMatrixScale = 0x20018010,
858  TransformMaskModellingMatrixOffset = 0x20018011,
859  TransformMaskModellingMatrixRotation = 0x20018012,
860 
861  ColorInterpolation = 0x20019000,
862  ColorInterpolationFaceColor = 0x20019001,
863  ColorInterpolationEdgeColor = 0x20019002,
864  ColorInterpolationMarkerColor = 0x20019003,
865  ColorInterpolationFaceIndex = 0x20019004,
866  ColorInterpolationEdgeIndex = 0x20019005,
867  ColorInterpolationMarkerIndex = 0x20019006,
868 
869  CuttingSectionAttribute = 0x2001a000,
870  CuttingSectionAttributeCuttingLevel = 0x2001a001,
871  CuttingSectionAttributeCappingLevel = 0x2001a002,
872  CuttingSectionAttributeMaterialPreference = 0x2001a003,
873  CuttingSectionAttributeEdgeWeight = 0x2001a004,
874  CuttingSectionAttributeTolerance = 0x2001a005,
875 
876  };
877 
878 private:
879  Search() {}
880 };
881 
882 
884 class HPS_API Material
885 {
886 public:
887 
890  enum class Type : uint32_t
891  {
892  None = 0,
893  FullMaterial,
894  RGBColor,
895  RGBAColor,
896  MaterialIndex,
897  TextureName,
898  ModulatedTexture,
899  CubeMapName,
900  ModulatedCubeMap,
901  GlossValue,
902  DiffuseChannelAlpha
903  };
904 
907  enum class Channel : uint32_t
908  {
909  DiffuseColor = 1,
910  DiffuseTexture = 2,
911  Specular = 3,
912  Emission = 4,
913  Transmission = 5,
914  Mirror = 6,
915  Bump = 7,
916  EnvironmentTexture = 8,
917  EnvironmentCubeMap = 9,
918  Gloss = 10,
919  Alpha = 11
920  };
921 
923  class HPS_API Color
924  {
925  public:
926 
929  enum class Channel : uint32_t
930  {
931  DiffuseColor = 1,
932  Specular = 3,
933  Emission = 4,
934  Mirror = 6
935  };
936 
937  private:
938  Color() {}
939  };
940 
942  class HPS_API Texture
943  {
944  public:
945 
948  enum class Channel : uint32_t
949  {
950  DiffuseTexture = 2,
951  Specular = 3,
952  Emission = 4,
953  Transmission = 5,
954  Mirror = 6,
955  Bump = 7,
956  EnvironmentTexture = 8,
957  EnvironmentCubeMap = 9
958  };
959 
962  enum class Parameterization : uint32_t
963  {
965  Cylinder,
966 
968  PhysicalReflection,
969 
971  Object,
972 
978  NaturalUV,
979 
981  ReflectionVector,
982 
984  SurfaceNormal,
985 
987  Sphere,
988 
990  UV,
991 
993  World
994  };
995 
998  enum class Tiling : uint32_t
999  {
1002  Clamp,
1003 
1005  Repeat,
1006 
1008  Reflect,
1009 
1012  Trim
1013  };
1014 
1017  enum class Interpolation : uint32_t
1018  {
1020  None,
1021 
1023  Bilinear
1024  };
1025 
1028  enum class Decimation : uint32_t
1029  {
1031  None,
1032 
1035  Anisotropic,
1036 
1038  Mipmap
1039  };
1040 
1044  enum class ChannelMapping : uint32_t
1045  {
1046  Red,
1047  Green,
1048  Blue,
1049  Alpha,
1050  Zero,
1051  One,
1052  Luminance
1053  };
1054 
1055  private:
1056  Texture() {}
1057  };
1058 
1059 private:
1060  Material() {}
1061 };
1062 
1063 
1064 class HPS_API PostProcessEffects
1065 {
1066 public:
1067 
1068  class HPS_API AmbientOcclusion
1069  {
1070  public:
1071 
1074  enum class Quality : uint32_t
1075  {
1076  Fastest,
1077  Nicest
1078  };
1079 
1080  private:
1081  AmbientOcclusion() {}
1082  };
1083 
1084  class HPS_API Bloom
1085  {
1086  public:
1090  enum class Shape : uint32_t
1091  {
1092  Star,
1093  Radial
1094  };
1095 
1096  private:
1097  Bloom() {}
1098  };
1099 
1100 private:
1101  PostProcessEffects() {}
1102 };
1103 
1104 class HPS_API Performance
1105 {
1106 public:
1107 
1111  enum class DisplayLists : uint32_t
1112  {
1114  None,
1115 
1118  Geometry,
1119 
1122  Segment
1123  };
1124 
1133  enum class StaticModel : uint32_t
1134  {
1135 
1136  None,
1137  Attribute,
1138  AttributeSpatial
1139  };
1140 
1141 
1142 private:
1143  Performance() {}
1144 };
1145 
1146 
1147 class HPS_API AttributeLock
1148 {
1149 public:
1150 
1152  enum class Type : uint32_t
1153  {
1154  Everything = 0x01000000,
1155 
1156  Visibility = 0x02000000,
1157 
1158  VisibilityCuttingSections,
1159  VisibilityCutEdges,
1160  VisibilityCutFaces,
1161  VisibilityWindows,
1162  VisibilityText,
1163  VisibilityLines,
1164  VisibilityEdgeLights,
1165  VisibilityMarkerLights,
1166  VisibilityFaceLights,
1167  VisibilityGenericEdges,
1168  VisibilityHardEdges,
1169  VisibilityAdjacentEdges,
1170  VisibilityInteriorSilhouetteEdges,
1171  VisibilityShadowEmitting,
1172  VisibilityShadowReceiving,
1173  VisibilityShadowCasting,
1174  VisibilityMarkers,
1175  VisibilityVertices,
1176  VisibilityFaces,
1177  VisibilityPerimeterEdges,
1178  VisibilityNonCulledEdges,
1179  VisibilityMeshQuadEdges,
1180  VisibilityCutGeometry,
1181  VisibilityEdges,
1182  VisibilityGeometry,
1183  VisibilityLights,
1184  VisibilityShadows,
1185 
1186  Material = 0x03000000,
1187 
1188  MaterialGeometry,
1189  MaterialCutGeometry,
1190 
1191  MaterialAmbientLightUpColor,
1192  MaterialAmbientLightDownColor,
1193  MaterialAmbientLightColor,
1194 
1195  MaterialWindowColor,
1196  MaterialWindowContrastColor,
1197 
1198  MaterialLightColor,
1199  MaterialLineColor,
1200  MaterialMarkerColor,
1201  MaterialTextColor,
1202  MaterialCutEdgeColor,
1203 
1204  MaterialVertex,
1205  MaterialVertexDiffuse,
1206  MaterialVertexDiffuseColor,
1207  MaterialVertexDiffuseAlpha,
1208  MaterialVertexDiffuseTexture,
1209  MaterialVertexSpecular,
1210  MaterialVertexMirror,
1211  MaterialVertexTransmission,
1212  MaterialVertexEmission,
1213  MaterialVertexEnvironment,
1214  MaterialVertexBump,
1215  MaterialVertexGloss,
1216 
1217  MaterialEdge,
1218  MaterialEdgeDiffuse,
1219  MaterialEdgeDiffuseColor,
1220  MaterialEdgeDiffuseAlpha,
1221  MaterialEdgeDiffuseTexture,
1222  MaterialEdgeSpecular,
1223  MaterialEdgeMirror,
1224  MaterialEdgeTransmission,
1225  MaterialEdgeEmission,
1226  MaterialEdgeEnvironment,
1227  MaterialEdgeBump,
1228  MaterialEdgeGloss,
1229 
1230  MaterialFace,
1231  MaterialFaceDiffuse,
1232  MaterialFaceDiffuseColor,
1233  MaterialFaceDiffuseAlpha,
1234  MaterialFaceDiffuseTexture,
1235  MaterialFaceSpecular,
1236  MaterialFaceMirror,
1237  MaterialFaceTransmission,
1238  MaterialFaceEmission,
1239  MaterialFaceEnvironment,
1240  MaterialFaceBump,
1241  MaterialFaceGloss,
1242 
1243  MaterialBackFace,
1244  MaterialBackFaceDiffuse,
1245  MaterialBackFaceDiffuseColor,
1246  MaterialBackFaceDiffuseAlpha,
1247  MaterialBackFaceDiffuseTexture,
1248  MaterialBackFaceSpecular,
1249  MaterialBackFaceMirror,
1250  MaterialBackFaceTransmission,
1251  MaterialBackFaceEmission,
1252  MaterialBackFaceEnvironment,
1253  MaterialBackFaceBump,
1254  MaterialBackFaceGloss,
1255 
1256  MaterialFrontFace,
1257  MaterialFrontFaceDiffuse,
1258  MaterialFrontFaceDiffuseColor,
1259  MaterialFrontFaceDiffuseAlpha,
1260  MaterialFrontFaceDiffuseTexture,
1261  MaterialFrontFaceSpecular,
1262  MaterialFrontFaceMirror,
1263  MaterialFrontFaceTransmission,
1264  MaterialFrontFaceEmission,
1265  MaterialFrontFaceEnvironment,
1266  MaterialFrontFaceBump,
1267  MaterialFrontFaceGloss,
1268 
1269  MaterialCutFace,
1270  MaterialCutFaceDiffuse,
1271  MaterialCutFaceDiffuseColor,
1272  MaterialCutFaceDiffuseAlpha,
1273  MaterialCutFaceDiffuseTexture,
1274  MaterialCutFaceSpecular,
1275  MaterialCutFaceMirror,
1276  MaterialCutFaceTransmission,
1277  MaterialCutFaceEmission,
1278  MaterialCutFaceEnvironment,
1279  MaterialCutFaceBump,
1280  MaterialCutFaceGloss,
1281 
1282  Camera = 0x04000000,
1283  };
1284 
1285 private:
1286  AttributeLock() {}
1287 };
1288 
1289 class HPS_API Drawing
1290 {
1291 public:
1292 
1295  enum class Handedness : uint32_t
1296  {
1297  None,
1298  Left,
1299  Right
1300  };
1301 
1304  enum class Overlay : uint32_t
1305  {
1307  None,
1308 
1311  Default,
1312 
1315  WithZValues,
1316 
1321  InPlace,
1322  };
1323 
1326  enum class ClipOperation : uint32_t
1327  {
1328  Keep,
1329  Remove,
1330  };
1331 
1334  enum class ClipSpace : uint32_t
1335  {
1336  Window,
1337  World,
1338  Object,
1339  };
1340 
1341 private:
1342  Drawing() {}
1343 };
1344 
1345 
1346 class HPS_API HiddenLine
1347 {
1348 public:
1349 
1353  enum class Algorithm : uint32_t
1354  {
1355  None,
1356  ZBuffer,
1357  ZSort,
1358  };
1359 
1360 private:
1361  HiddenLine() {}
1362 };
1363 
1364 
1366 class HPS_API Selection
1367 {
1368 public:
1369 
1372  enum class Level : uint32_t
1373  {
1374  Segment,
1375  Entity,
1376  Subentity,
1377  };
1378 
1381  enum class Sorting: uint32_t
1382  {
1383  Off,
1384 
1391  Proximity,
1392 
1393  ZSorting,
1394 
1395  Default
1396  };
1397 
1400  enum class Algorithm : uint32_t
1401  {
1404  Visual,
1405 
1408  Analytic
1409  };
1410 
1413  enum class Granularity : uint32_t
1414  {
1415  General,
1416  Detailed
1417  };
1418 
1419 private:
1420  Selection() {}
1421 };
1422 
1423 
1427 
1429 class HPS_API Camera
1430 {
1431 public:
1432 
1435  enum class Projection : uint32_t
1436  {
1437  Default = 1 ,
1438  Perspective,
1439  Orthographic,
1440  Stretched,
1441  };
1442 
1443 private:
1444  Camera() {}
1445 };
1446 
1447 
1449 class HPS_API Selectability
1450 {
1451 public:
1455  enum class Value : uint32_t
1456  {
1457  Off = 0,
1458  On,
1459  ForcedOn
1460  };
1461 
1462 private:
1463  Selectability() {}
1464 };
1465 
1466 
1468 class HPS_API Transparency
1469 {
1470 public:
1471 
1474  enum class Method : uint32_t
1475  {
1476  None,
1477  Blended,
1478  ScreenDoor
1479  };
1480 
1483  enum class Algorithm : uint32_t
1484  {
1485  None,
1486  Painters,
1487  ZSortNicest,
1488  ZSortFastest,
1489  DepthPeeling,
1490  WeightedBlended
1491  };
1492 
1496  enum class AreaUnits : uint32_t
1497  {
1498  Percent,
1499  Pixels
1500  };
1501 
1505  enum class Preference
1506  {
1507  Nicest,
1508  Fastest,
1509  };
1510 
1511 private:
1512  Transparency() {}
1513 };
1514 
1515 
1517 class HPS_API Marker
1518 {
1519 public:
1521  enum class DrawingPreference : uint32_t
1522  {
1523  Nicest, // !< Markers should always be drawn at the requested size at the possible cost of performance.
1524  Fastest,
1525  };
1526 
1529  enum class SizeUnits : uint32_t
1530  {
1531  ScaleFactor,
1532  ObjectSpace,
1533  SubscreenRelative,
1534  WindowRelative,
1535  WorldSpace,
1536  Points,
1537  Pixels
1538  };
1539 
1540 private:
1541  Marker() {}
1542 };
1543 
1544 
1546 class HPS_API Lighting
1547 {
1548 public:
1549 
1552  enum class InterpolationAlgorithm : uint32_t
1553  {
1554  Phong,
1555  Gouraud,
1556  Flat
1557  };
1558 
1559 private:
1560  Lighting() {}
1561 };
1562 
1564 class HPS_API Text
1565 {
1566 public:
1567 
1570  enum class Alignment : uint32_t
1571  {
1572  TopLeft,
1573  CenterLeft,
1574  BottomLeft,
1575  TopCenter,
1576  Center,
1577  BottomCenter,
1578  TopRight,
1579  CenterRight,
1580  BottomRight
1581  };
1582 
1585  enum class ReferenceFrame : uint32_t
1586  {
1587  WorldAligned,
1588  PathAligned
1589  };
1590 
1593  enum class Justification : uint32_t
1594  {
1595  Left,
1596  Right,
1597  Center
1598  };
1599 
1602  enum class Transform : uint32_t
1603  {
1605  Transformable,
1608  NonTransformable,
1610  CharacterPositionOnly,
1613  CharacterPositionAdjusted,
1615  NonScalingTransformable
1616  };
1617 
1620  enum class Renderer : uint32_t
1621  {
1622  Default,
1623  Driver,
1624  Truetype,
1625  };
1626 
1629  enum class Preference : uint32_t
1630  {
1631  Default,
1632  Vector,
1633  Raster,
1634  Exterior
1635  };
1636 
1639  enum class Rotation : uint32_t
1640  {
1641  None,
1642  Rotate,
1643  FollowPath
1644  };
1645 
1646 
1649  enum class SizeUnits : uint32_t
1650  {
1651  ObjectSpace,
1652  SubscreenRelative,
1653  WindowRelative,
1654  WorldSpace,
1655  Points,
1656  Pixels
1657  };
1658 
1661  enum class SizeToleranceUnits : uint32_t
1662  {
1663  ObjectSpace,
1664  SubscreenRelative,
1665  WindowRelative,
1666  WorldSpace,
1667  Points,
1668  Pixels,
1669  Percent
1670  };
1671 
1674  enum class MarginUnits : uint32_t
1675  {
1676  ObjectSpace,
1677  SubscreenRelative,
1678  WindowRelative,
1679  WorldSpace,
1680  Points,
1681  Pixels,
1682  Percent
1683  };
1684 
1687  enum class GreekingUnits : uint32_t
1688  {
1689  ObjectSpace,
1690  SubscreenRelative,
1691  WindowRelative,
1692  WorldSpace,
1693  Points,
1694  Pixels
1695  };
1696 
1699  enum class GreekingMode : uint32_t
1700  {
1701  Nothing,
1702  Lines,
1703  Box
1704  };
1705 
1708  enum class RegionAlignment : uint32_t
1709  {
1710  Top,
1711  Center,
1712  Bottom
1713  };
1714 
1717  enum class LeaderLineSpace : uint32_t
1718  {
1719  Object,
1720  World,
1721  };
1722 
1725  enum class RegionFitting : uint32_t
1726  {
1727  Left,
1728  Center,
1729  Right,
1730  Spacing,
1731  Width,
1732  Auto,
1733  };
1734 private:
1735  Text() {}
1736 };
1737 
1738 
1740 class HPS_API Line
1741 {
1742 public:
1743 
1747  enum class CoordinateSpace : uint32_t
1748  {
1749  Object,
1750  World,
1751  NormalizedInnerWindow,
1752  NormalizedInnerPixel
1753  };
1754 
1758  enum class SizeUnits : uint32_t
1759  {
1760  ScaleFactor,
1761  ObjectSpace,
1762  SubscreenRelative,
1763  WindowRelative,
1764  WorldSpace,
1765  Points,
1766  Pixels
1767  };
1768 
1769 private:
1770  Line() {}
1771 };
1772 
1773 
1775 class HPS_API Edge
1776 {
1777 public:
1778 
1781  enum class SizeUnits : uint32_t
1782  {
1783  ScaleFactor,
1784  ObjectSpace,
1785  SubscreenRelative,
1786  WindowRelative,
1787  WorldSpace,
1788  Points,
1789  Pixels
1790  };
1791 
1792 private:
1793  Edge() {}
1794 };
1795 
1796 
1798 class HPS_API CuttingSection
1799 {
1800 public:
1801 
1804  enum class Mode : uint32_t
1805  {
1806  None,
1807  Round,
1808  Square,
1809  Plane
1810  };
1811 
1814  enum class CappingLevel : uint32_t
1815  {
1816  Entity,
1817  Segment,
1818  SegmentTree
1819  };
1820 
1823  enum class ToleranceUnits : uint32_t
1824  {
1825  Percent,
1826  WorldSpace,
1827  };
1828 
1831  enum class CuttingLevel : uint32_t
1832  {
1833  Global,
1834  Local,
1835  };
1836 
1839  enum class MaterialPreference : uint32_t
1840  {
1841  Explicit,
1842  Implicit,
1843  };
1844 
1847  enum class GatheringLevel : uint32_t
1848  {
1849  Segment,
1850  SegmentTree
1851  };
1852 
1853 private:
1854  CuttingSection() {}
1855 };
1856 
1858 class HPS_API ContourLine
1859 {
1860 public:
1861 
1865  enum class Mode : uint32_t
1866  {
1867  Repeating,
1868  Explicit,
1869  };
1870 
1871 private:
1872  ContourLine() {}
1873 };
1874 
1877 enum class IOResult : uint32_t
1878 {
1879  Success,
1880  Failure,
1881  FileNotFound,
1882  UnableToOpenFile,
1883  InvalidOptions,
1884  InvalidSegment,
1885  InProgress,
1886  Canceled,
1887  UnableToLoadLibraries,
1888  VersionIncompatibility,
1889  InitializationFailed,
1890  UnsupportedFormat,
1891  InvalidFile,
1892 };
1893 
1895 class HPS_API LinePattern
1896 {
1897 public:
1898 
1901  enum class SizeUnits : uint32_t
1902  {
1903  ObjectSpace,
1904  SubscreenRelative,
1905  WindowRelative,
1906  WorldSpace,
1907  Points,
1908  Pixels,
1909  ScaleFactor
1910  };
1911 
1914  enum class InsetBehavior : uint32_t
1915  {
1916  Overlap,
1917  Trim,
1918  Inline
1919  };
1920 
1924  enum class Join : uint32_t
1925  {
1926  Mitre,
1927  Round,
1928  Bevel
1929  };
1930 
1933  enum class Cap : uint32_t
1934  {
1937  Butt,
1940  Square,
1943  Round,
1945  Mitre
1946  };
1947 
1950  enum class Justification : uint32_t
1951  {
1954  Center,
1956  Stretch
1957  };
1958 
1961  enum class Modifier : uint32_t
1962  {
1963  GlyphName,
1964  Enumerated
1965  };
1966 
1967 
1981  enum class Default : uint32_t
1982  {
1983  Solid,
1984  DashDot,
1985  Dashed,
1986  Dotted,
1987  Dash2Dot,
1988  Dash3Dot,
1989  LongDash,
1990  LongDashShortDash,
1991  LongDash2ShortDash,
1992  FineDot,
1993  };
1994 
1995 private:
1996  LinePattern() {}
1997 };
1998 
1999 
2001 class HPS_API Shape
2002 {
2003 public:
2004  enum class Default : uint32_t
2005  {
2006  Rectangle,
2007  RoundedRectangle,
2008  Oval,
2009  Ellipse,
2010  };
2011 
2012 private:
2013  Shape() {}
2014 };
2015 
2016 
2017 //Begin Glyphs
2019 class HPS_API Glyph
2020 {
2021 public:
2022 
2025  enum class Fill : uint32_t
2026  {
2027  None,
2028  Continuous,
2029  New,
2030  NewLoop
2031  };
2032 
2035  enum class ColorSource : uint32_t
2036  {
2037  Default,
2038  Explicit,
2039  Indexed
2040  };
2041 
2045  enum class Default : uint32_t
2046  {
2047  Circle,
2048  CircleWithDot,
2049  CircleWithPlus,
2050  CircleWithTimes,
2051  CircleWithCircle,
2052  SolidCircle,
2053  Dot,
2054  Plus,
2055  Times,
2056  Splat,
2057  Box,
2058  BoxWithDot,
2059  BoxWithTimes,
2060  SolidBox,
2061  Diamond,
2062  DiamondWithDot,
2063  DiamondWithPlus,
2064  SolidDiamond,
2065  TriangleUp,
2066  TriangleUpWithDot,
2067  SolidTriangleUp,
2068  TriangleDown,
2069  TriangleDownWithDot,
2070  SolidTriangleDown,
2071  TriangleRight,
2072  TriangleRightWithDot,
2073  SolidTriangleRight,
2074  TriangleLeft,
2075  TriangleLeftWithDot,
2076  SolidTriangleLeft,
2077  TriangleUpV,
2078  SolidTriangleUpV,
2079  TriangleDownV,
2080  SolidTriangleDownV,
2081  TriangleRightV,
2082  SolidTriangleRightV,
2083  TriangleLeftV,
2084  SolidTriangleLeftV,
2085  LetterY,
2086  LetterZ,
2087  CircleLetterY,
2088  CircleLetterZ,
2089  VerticalBar,
2090  HorizontalBar,
2091  SlantLeft,
2092  SlantRight,
2093  WidePlus,
2094  SolidWidePlus,
2095  WideTimes,
2096  SolidWideTimes,
2097  Pound,
2098  Sphere,
2099  };
2100 
2101 private:
2102  Glyph() {}
2103 };
2104 
2105 
2107 class HPS_API Bounding
2108 {
2109 public:
2110 
2113  enum class Type : uint32_t
2114  {
2115  None,
2116  Sphere,
2117  Cuboid
2118  };
2119 
2120 private:
2121  Bounding() {}
2122 };
2123 
2124 
2126 class HPS_API Condition
2127 {
2128 public:
2129 
2130  enum class Intrinsic : uint32_t
2131  {
2132  Extent,
2133  DrawPass,
2134  InnerPixelWidth,
2135  InnerPixelHeight,
2136  Selection,
2137  QuickMovesProbe,
2138  };
2139 
2140 private:
2141  Condition() {}
2142 };
2143 
2144 
2146 class HPS_API Grid
2147 {
2148 public:
2149 
2152  enum class Type : uint32_t
2153  {
2154  Quadrilateral,
2155  Radial
2156  };
2157 
2158 private:
2159  Grid() {}
2160 };
2161 
2162 
2164 {
2165 public:
2166 
2167  enum class UserData : uint32_t
2168  {
2169  None,
2170  Discard,
2171  Preserve,
2172  Merge,
2173  Localize,
2174  };
2175 
2176  enum class Scope : uint32_t
2177  {
2178  SubSegments,
2179  SubsegmentsAndIncludes,
2180  SegmentOnly,
2181  };
2182 
2183  enum class Expansion : uint32_t
2184  {
2185  None,
2186  Includes,
2187  References,
2188  IncludesAndReferences,
2189  };
2190 
2191  enum class Matrix : uint32_t
2192  {
2193  None,
2194  Localize,
2195  Collapse,
2196  };
2197 
2198  enum class Reorganization : uint32_t
2199  {
2200  None,
2201  Attribute,
2202  Spatial,
2203  AttributeSpatial,
2204  };
2205 
2206 private:
2208 };
2209 
2210 
2212 class HPS_API Coordinate
2213 {
2214 public:
2215 
2219  enum class Space : uint32_t
2220  {
2221  Object,
2222  World,
2223  Camera,
2224  Window,
2225  Pixel,
2226  InnerWindow,
2227  InnerPixel,
2228  NormalizedInnerWindow,
2229  NormalizedInnerPixel,
2230  NormalizedWindow,
2231  NormalizedPixel,
2232  };
2233 
2234 private:
2235  Coordinate() {}
2236 };
2237 
2239 class HPS_API Extent
2240 {
2241 public:
2242 
2243  enum class ClipRegion : uint32_t
2244  {
2245  Include,
2246  Ignore
2247  };
2248 
2249 private:
2250  Extent() {}
2251 };
2252 
2253 class HPS_API GPU
2254 {
2255 public:
2256 
2261  enum class Preference
2262  {
2263  HighPerformance,
2264  Integrated,
2265  Specific,
2266  Default,
2267  };
2268 
2269 private:
2270  GPU() {}
2271 };
2272 
2273  typedef double Time;
2274 
2275 #ifdef _MSC_VER
2276 # ifndef HPS_INLINE
2277 # define HPS_INLINE __forceinline
2278 # endif
2279 #else
2280 # define HPS_INLINE inline
2281 #endif
2282 
2283 #ifndef HPS_UNREFERENCED
2284 #define HPS_UNREFERENCED(param) ((void)(param))
2285 #endif
2286 
2287 
2288 const double PI = 3.141592653589793238462643383279502884197169399375105820974944592308;
2289 
2290 template<typename T>
2291 HPS_INLINE T Degrees_To_Radians(T const & degrees)
2292 {
2293  return degrees * (T)(PI / 180.0);
2294 }
2295 
2296 template<typename T>
2297 HPS_INLINE T Radians_To_Degrees(T const & radians)
2298 {
2299  return radians * (T)(180.0 / PI);
2300 }
2301 
2302 template<typename T>
2303 HPS_INLINE void SinCos(T const & angle, T & sine, T & cosine) {
2304  T a = Degrees_To_Radians(angle);
2305  cosine = cos(a);
2306  sine = sin(a);
2307 }
2308 
2309 template<typename T>
2310 HPS_INLINE T Cos(T const & angle) {
2311  return cos (Degrees_To_Radians(angle));
2312 }
2313 
2314 template<typename T>
2315 HPS_INLINE T Sin(T const & angle) {
2316  return sin (Degrees_To_Radians(angle));
2317 }
2318 
2319 template<typename T>
2320 HPS_INLINE T ACos(T const & x) {
2321  if (x > 1)
2322  return 0;
2323  if (x < -1)
2324  return 180;
2325  return Radians_To_Degrees(acos(x));
2326 }
2327 
2328 template<typename T>
2329 HPS_INLINE T ATan2(T const & y, T const & x) {
2330  if (x == 0 && y == 0)
2331  return 0;
2332  return Radians_To_Degrees(atan2(y, x));
2333 }
2334 
2335 
2336 template <typename F> struct Float_Traits {};
2337 template <> struct Float_Traits<float> {
2338  typedef double Alternative;
2339  static const int Type = 1;
2340  static float Epsilon () { return 1.0e-30f; }
2341 };
2342 template <> struct Float_Traits<double> {
2343  typedef float Alternative;
2344  static const int Type = 2;
2345  static double Epsilon () { return 1.0e-300; }
2346 };
2347 
2348 
2349 
2351 class HPS_API Float {
2352 private:
2353  enum Parts {
2354 # if HOOPS_BIGENDIAN
2355  High, Low
2356 # else
2357  Low, High
2358 # endif
2359  };
2360 
2361  // & functions for a float represented in an int, * version for a double in an array of 2 ints
2362  static HPS_INLINE bool is_infinite(int32_t const & v) { return (v & 0x7FFFFFFF) == 0x7F800000; }
2363  static HPS_INLINE bool is_infinite(uint32_t const & v) { return (v & 0x7FFFFFFF) == 0x7F800000; }
2364  static HPS_INLINE bool is_infinite(int32_t const * v) { return (v[High] & 0x7FFFFFFF) == 0x7FF00000 && v[Low] == 0; }
2365  static HPS_INLINE bool is_infinite(uint32_t const * v) { return (v[High] & 0x7FFFFFFF) == 0x7FF00000 && v[Low] == 0; }
2366 
2367  static HPS_INLINE bool is_nan(int32_t const & v) {
2368  uint32_t exp = v & 0x7F800000, mantissa = v & 0x007FFFFF;
2369  return exp == 0x7F800000 && mantissa != 0;
2370  }
2371  static HPS_INLINE bool is_nan(uint32_t const & v) {
2372  uint32_t exp = v & 0x7F800000, mantissa = v & 0x007FFFFF;
2373  return exp == 0x7F800000 && mantissa != 0;
2374  }
2375  static HPS_INLINE bool is_nan(int32_t const * v) {
2376  uint32_t exp = v[High] & 0x7FF00000, mantissa_high = v[High] & 0x000FFFFF;
2377  return exp == 0x7FF00000 && (mantissa_high | v[Low]) != 0;
2378  }
2379  static HPS_INLINE bool is_nan(uint32_t const * v) {
2380  uint32_t exp = v[High] & 0x7FF00000, mantissa_high = v[High] & 0x000FFFFF;
2381  return exp == 0x7FF00000 && (mantissa_high | v[Low]) != 0;
2382  }
2383 
2384  static HPS_INLINE bool is_special(int32_t const & v) { return (v & 0x7F800000) == 0x7F800000; }
2385  static HPS_INLINE bool is_special(uint32_t const & v) { return (v & 0x7F800000) == 0x7F800000; }
2386  static HPS_INLINE bool is_special(int32_t const * v) { return (v[High] & 0x7FF00000) == 0x7FF00000; }
2387  static HPS_INLINE bool is_special(uint32_t const * v) { return (v[High] & 0x7FF00000) == 0x7FF00000; }
2388 public:
2389 
2391  static const float Infinity;
2393  static const float NegativeInfinity;
2394 
2396  static HPS_INLINE bool IsInfinite(float const & a) { return is_infinite (extract_uint32_t(a)); }
2397  static HPS_INLINE bool IsInfinite(double const & a) {
2398  uint32_t v[2];
2399  memcpy (v, &a, sizeof(double));
2400  return is_infinite (v);
2401  }
2402 
2404  static HPS_INLINE bool IsNAN(float const & a) { return is_nan (extract_uint32_t(a)); }
2405  static HPS_INLINE bool IsNAN(double const & a) {
2406  uint32_t v[2];
2407  memcpy (v, &a, sizeof(double));
2408  return is_nan (v);
2409  }
2410 
2412  static HPS_INLINE bool IsAbnormal(float const & a) { return is_special (extract_uint32_t(a)); }
2413  static HPS_INLINE bool IsAbnormal(double const & a) {
2414  uint32_t v[2];
2415  memcpy (v, &a, sizeof(double));
2416  return is_special (v);
2417  }
2418 
2421  static HPS_INLINE bool Equals(float const & a, float const & b, int tolerance = 32);
2422  static HPS_INLINE bool Equals(double const & a, double const & b, int tolerance = 32);
2423 
2424 #ifndef HOOPS_DEFINED
2425  template <typename Alloc>
2426  static HPS_INLINE bool Equals(std::vector<float, Alloc> const & a, std::vector<float, Alloc> const & b, int tolerance = 32)
2427  {
2428  if (a.size() != b.size())
2429  return false;
2430 
2431  auto it1 = a.begin();
2432  auto it2 = b.begin();
2433  auto const end = a.end();
2434  for ( ; it1 != end; ++it1, ++it2)
2435  {
2436  if (!Equals(*it1, *it2, tolerance))
2437  return false;
2438  }
2439  return true;
2440  }
2441 #endif
2442 
2443  static HPS_INLINE uint32_t extract_sign_bit(float const & a) {
2444  return extract_uint32_t(a) & 0x80000000;
2445  }
2446  static HPS_INLINE uint32_t extract_sign_bit(double const & a) {
2447  uint32_t v[2];
2448  memcpy (v, &a, sizeof(double));
2449  return v[High] & 0x80000000;
2450  }
2451 
2452  static HPS_INLINE void apply_sign_bit(float & a, uint32_t const & sign_bit) {
2453  uint32_t v = extract_uint32_t(a);
2454  v &= 0x7FFFFFFF;
2455  v |= sign_bit;
2456  inject_uint32_t(a, v);
2457  }
2458  static HPS_INLINE void apply_sign_bit(double & a, uint32_t const & sign_bit) {
2459  uint32_t v[2];
2460  memcpy (v, &a, sizeof(double));
2461  v[High] &= 0x7FFFFFFF;
2462  v[High] |= sign_bit;
2463  memcpy (&a, v, sizeof(double));
2464  }
2465 
2466 
2467  static HPS_INLINE unsigned char unit_to_byte(float const & a) {
2468  uint32_t v = extract_uint32_t(a);
2469 
2470  v &= 0x7FFFFFFF;
2471  if (v < 0x3B800000)
2472  return 0;
2473 
2474  v--;
2475 
2476  uint32_t exp = v >> 23;
2477  uint32_t man = (v & 0x007FFFFF) | 0x00800000;
2478 
2479  return (unsigned char) (man >> (16 + 126 - exp));
2480  }
2481 
2482  static HPS_INLINE unsigned char unit_to_byte_scaled(float const & a, unsigned char mix) {
2483  uint32_t v = extract_uint32_t(a);
2484 
2485  v &= 0x7FFFFFFF;
2486  if (v < 0x3B800000)
2487  return 0;
2488 
2489  v--;
2490 
2491  uint32_t exp = v >> 23;
2492  uint32_t man = (v & 0x007FFFFF) | 0x00800000;
2493 
2494  uint32_t x = (man >> (16 + 126 - exp));
2495 
2496  return (unsigned char) ((x * (mix+1)) >> 8);
2497  }
2498 
2499 
2500  static HPS_INLINE bool match(float const & a, float const & b) {
2501  uint32_t va = extract_uint32_t(a);
2502  uint32_t vb = extract_uint32_t(b);
2503 
2504  if (((va | vb) & 0x7FFFFFFF) == 0)
2505  return true;
2506 
2507  return va == vb;
2508  }
2509  static HPS_INLINE bool match(double const & a, double const & b) {
2510  return a == b;
2511  }
2512 
2513 
2514  static HPS_INLINE void replace_if_smaller(float & a, float const & b) {
2515  if (b < a)
2516  a = b;
2517  }
2518  static HPS_INLINE void replace_if_smaller(double & a, double const & b) {
2519  if (b < a)
2520  a = b;
2521  }
2522 
2523  static HPS_INLINE void replace_if_larger(float & a, float const & b) {
2524  if (b > a)
2525  a = b;
2526  }
2527  static HPS_INLINE void replace_if_larger(double & a, double const & b) {
2528  if (b > a)
2529  a = b;
2530  }
2531 
2532 
2533  static HPS_INLINE uint32_t extract_uint32_t(float const & a) {
2534  uint32_t i;
2535  memcpy(&i, &a, sizeof(float));
2536  return i;
2537  }
2538 
2539  static HPS_INLINE void inject_uint32_t(float & a, uint32_t const & i) {
2540  memcpy(&a, &i, sizeof(float));
2541  }
2542 
2543  static HPS_INLINE float C2F(unsigned char x) {
2544  //return (float)x * (1.0f/255.0f);
2545  return char_to_float[x];
2546  }
2547 
2548 
2549  // SSE convenience functions
2550  static HPS_INLINE void pack_4(float const & f, float * m) {
2551  memcpy(&m[0], &f, sizeof(float));
2552  memcpy(&m[1], &f, sizeof(float));
2553  memcpy(&m[2], &f, sizeof(float));
2554  memcpy(&m[3], &f, sizeof(float));
2555  }
2556 
2557  static HPS_INLINE void pack_4(float const & f0, float const & f1, float const & f2, float const & f3, float * m) {
2558  memcpy(&m[0], &f0, sizeof(float));
2559  memcpy(&m[1], &f1, sizeof(float));
2560  memcpy(&m[2], &f2, sizeof(float));
2561  memcpy(&m[3], &f3, sizeof(float));
2562  }
2563 
2564  static HPS_INLINE void unpack_4(float * f0, float const * const m) {
2565  memcpy(f0, m, sizeof(float)*4);
2566  }
2567 
2568  static HPS_INLINE void unpack_4(float & f0, float & f1, float & f2, float & f3, float const * const m) {
2569  memcpy(&f0, &m[0], sizeof(float));
2570  memcpy(&f1, &m[1], sizeof(float));
2571  memcpy(&f2, &m[2], sizeof(float));
2572  memcpy(&f3, &m[3], sizeof(float));
2573  }
2574 
2575 private:
2576  static const float char_to_float[256];
2577 
2578  Float();
2579 };
2580 
2581 
2583 
2584 
2585 template <typename T> HPS_INLINE T * Alter (T const * a) { return const_cast<T *>(a); }
2586 template <typename T> HPS_INLINE T & Alter (T const & a) { return const_cast<T &>(a); }
2587 
2588 template <typename T> HPS_INLINE T Abs (T const & a) { return a < 0 ? -a : a; }
2589 template <typename T> HPS_INLINE int Compare (T const & a, T const & b) { return a == b ? 0 : a < b ? -1 : 1; }
2590 template <typename T> HPS_INLINE int Sign (T const & a) { return Compare(a,(T)0); }
2591 template <typename T> HPS_INLINE void Swap (T & a, T & b) { T temp = a; a = b; b = temp; }
2592 template <typename T> HPS_INLINE int Floor(T const & a) { return ((a > 0 || (T)(int)a == a) ? (int)a : ((int)a - 1)); }
2593 template <typename T> HPS_INLINE int Ceiling(T const & a) { return ((a < 0 || (T)(int)a == a) ? (int)a : ((int)a + 1)); }
2594 
2595 template <typename T> HPS_INLINE T const & Min (T const & a, T const & b) { return a < b ? a : b; }
2596 template <typename T> HPS_INLINE T const & Min (T const & a, T const & b, T const & c) { return Min(Min(a,b),c); }
2597 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); }
2598 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); }
2599 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); }
2600 
2601 template <typename T> HPS_INLINE T const & Max (T const & a, T const & b) { return a > b ? a : b; }
2602 template <typename T> HPS_INLINE T const & Max (T const & a, T const & b, T const & c) { return Max(Max(a,b),c); }
2603 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); }
2604 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); }
2605 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); }
2606 
2607 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; }
2608 
2609 
2610 template <> HPS_INLINE float Abs<float> (float const & a) {
2611  uint32_t v = Float::extract_uint32_t(a);
2612  v &= 0x7FFFFFFF;
2613  float f;
2614  Float::inject_uint32_t(f,v);
2615  return f;
2616 }
2617 
2618 template <> HPS_INLINE int Sign<float> (float const & a) {
2619  uint32_t v = Float::extract_uint32_t(a);
2620 
2621  if ((v & 0x7FFFFFFF) == 0)
2622  return 0;
2623 
2624  return ((int32_t)(v & 0x80000000)>>31) | 0x01;
2625 }
2626 
2627 
2629 
2630 HPS_INLINE bool Float::Equals(float const & a, float const & b, int tolerance) {
2631  int32_t va = Float::extract_uint32_t(a);
2632  int32_t vb = Float::extract_uint32_t(b);
2633 
2634  if (is_special(va) || is_special(vb)) {
2635  if (is_infinite(va) || is_infinite(vb))
2636  return va == vb; // final check is for sign bits same
2637  if (is_nan(va) || is_nan(vb))
2638  return false;
2639  }
2640 
2641  int const close_to_zero = 0x36A00000; // (approx) 5.0e-6f;
2642  if ((va & 0x7FFFFFFF) == 0)
2643  return (vb & 0x7FFFFFFF) < close_to_zero;
2644  else if ((vb & 0x7FFFFFFF) == 0)
2645  return (va & 0x7FFFFFFF) < close_to_zero;
2646 
2647  uint32_t sign_mask = va ^ vb;
2648  (int32_t &)sign_mask >>= 31;
2649 
2650  int32_t diff = ((va + sign_mask) ^ (sign_mask & 0x7FFFFFFF)) -vb;
2651  int32_t v1 = tolerance + diff;
2652  int32_t v2 = tolerance - diff;
2653  return (v1|v2) >= 0;
2654 }
2655 
2656 HPS_INLINE bool Float::Equals(double const & a, double const & b, int tolerance) {
2657  int32_t va[2], vb[2];
2658  memcpy (va, &a, sizeof(double));
2659  memcpy (vb, &b, sizeof(double));
2660 
2661  if (is_special(va) || is_special(vb)) {
2662  if (is_infinite(va) || is_infinite(vb))
2663  return va[High] == vb[High] && va[Low] == vb[Low]; // final check is for sign bits same
2664  if (is_nan(va) || is_nan(vb))
2665  return false;
2666  }
2667 
2668  if ((va[High] == 0 && va[Low] == 0) || (vb[High] == 0 && vb[Low] == 0))
2669  return Abs(a - b) < 0.000000000000005;
2670 
2671  if (extract_sign_bit(a) != extract_sign_bit(b))
2672  return a == b; //-V550
2673 
2674  if (va[High] != vb[High])
2675  return false;
2676 
2677  return Abs(va[Low] - vb[Low]) <= tolerance;
2678 }
2679 
2681 
2682 
2683 HPS_INLINE bool Is_Abnormal (float const & f) { return Float::IsAbnormal (f); }
2684 HPS_INLINE bool Is_Abnormal (double const & d) { return Float::IsAbnormal (d); }
2685 
2686 template <typename T>
2687 HPS_INLINE bool Is_Abnormal (size_t count, T const * t) {
2688  while (count-- > 0)
2689  if (Is_Abnormal (*t++))
2690  return true;
2691  return false;
2692 }
2693 
2694 template <typename T>
2695 HPS_INLINE bool Is_Abnormal (int count, T const * t) {
2696  return count >= 0 && Is_Abnormal((size_t)count, t);
2697 }
2698 
2699 
2701 
2702 
2703 template <typename F> class HPS_TEMPLATE_API Vector_3D;
2704 template <typename F> class HPS_TEMPLATE_API Plane_3D;
2705 template <typename F> class HPS_TEMPLATE_API Vector_2D;
2706 template <typename F> class HPS_TEMPLATE_API Point_2D;
2707 
2708 
2709 template <typename F>
2710 class HPS_TEMPLATE_API Point_3D {
2711  public:
2712  F x;
2713  F y;
2714  F z;
2715 
2716  Point_3D () {}
2717  Point_3D (F v1, F v2, F v3) : x (v1), y (v2), z (v3) {}
2718 
2719  template <typename D>
2720  explicit Point_3D (Point_3D<D> const & that) : x ((F)that.x), y ((F)that.y), z ((F)that.z) {}
2721 
2722  explicit Point_3D (Vector_3D<F> const & v);
2723  explicit Point_3D (Vector_2D<F> const & v);
2724  explicit Point_3D (Point_2D<F> const & that);
2725 
2726  Point_3D const operator- () const { return Point_3D (-x, -y, -z); }
2727 
2728  bool operator== (Point_3D const & p) const { return x == p.x && y == p.y && z == p.z; }
2729  bool operator!= (Point_3D const & p) const { return !(*this == p); }
2730 
2731  bool Equals(Point_3D const & p, int in_tolerance = 32) const {
2732  return Float::Equals(x, p.x, in_tolerance) &&
2733  Float::Equals(y, p.y, in_tolerance) &&
2734  Float::Equals(z, p.z, in_tolerance);
2735  }
2736 
2737 
2738  Point_3D & operator*= (F s) { x *= s; y *= s; z *= s; return *this; }
2739  Point_3D & operator/= (F s) { return operator*= ((F)1 / s); }
2740  Point_3D const operator* (F s) const { return Point_3D (x * s, y * s, z * s); }
2741  Point_3D const operator/ (F s) const { return operator* ((F)1 / s); }
2742 
2743  F & operator[] (size_t i) { return (&x)[i]; }
2744  F const & operator[] (size_t i) const { return (&x)[i]; }
2745 
2746  Point_3D & operator+= (Vector_3D<F> const & v);
2747  Point_3D & operator-= (Vector_3D<F> const & v);
2748  Point_3D & operator*= (Vector_3D<F> const & v);
2749  Point_3D & operator/= (Vector_3D<F> const & v);
2750  Point_3D const operator* (Vector_3D<F> const & v) const;
2751  Point_3D const operator/ (Vector_3D<F> const & v) const;
2752 
2753  Point_3D & operator+= (Vector_2D<F> const & v);
2754  Point_3D & operator-= (Vector_2D<F> const & v);
2755  Point_3D & operator*= (Vector_2D<F> const & v);
2756  Point_3D & operator/= (Vector_2D<F> const & v);
2757  Point_3D const operator* (Vector_2D<F> const & v) const;
2758  Point_3D const operator/ (Vector_2D<F> const & v) const;
2759 
2760  Vector_3D<F> const operator- (Point_3D const & p) const;
2761 
2762  Point_3D const operator+ (Vector_3D<F> const & v) const;
2763  Point_3D const operator- (Vector_3D<F> const & v) const;
2764 
2765  Point_3D const operator+ (Vector_2D<F> const & v) const;
2766  Point_3D const operator- (Vector_2D<F> const & v) const;
2767 
2768  static HPS_INLINE Point_3D Origin() {return Point_3D (0, 0, 0);};
2769  static HPS_INLINE Point_3D Zero() {return Point_3D (0, 0, 0);}; //-V524
2770 };
2771 
2772 typedef Point_3D<float> Point;
2773 typedef Point_3D<double> DPoint;
2774 
2775 
2776 
2777 template <typename F, typename S>
2778 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)); }
2779 
2780 template <typename F>
2781 HPS_INLINE Point_3D<F> Midpoint (Point_3D<F> const & a, Point_3D<F> const & b) {
2782  return Point_3D<F> (a.x + b.x, a.y + b.y, a.z + b.z) * 0.5f;
2783 }
2784 
2785 template <typename F>
2786 HPS_INLINE Point_3D<F> Midpoint (Point_3D<F> const & a, Point_3D<F> const & b, Point_3D<F> const & c) {
2787  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);
2788 }
2789 
2790 template <typename F>
2791 HPS_INLINE bool Is_Abnormal (Point_3D<F> const & p) {
2792  return Is_Abnormal (p.x) || Is_Abnormal (p.y) || Is_Abnormal (p.z);
2793 }
2794 
2795 
2796 template <typename F>
2797 class HPS_TEMPLATE_API Point_2D {
2798 public:
2799  F x;
2800  F y;
2801 
2802  Point_2D () {}
2803  Point_2D (F v1, F v2) : x (v1), y (v2) {}
2804 
2805  template <typename D>
2806  explicit Point_2D (Point_2D<D> const & that) : x ((F)that.x), y ((F)that.y) {}
2807 
2808  explicit Point_2D (Point_3D<F> const & that) : x ((F)that.x), y ((F)that.y) {}
2809  explicit Point_2D (Vector_2D<F> const & v);
2810 
2811  Point_2D const operator- () const { return Point_2D (-x, -y); }
2812 
2813  bool operator== (Point_2D const & p) const { return x == p.x && y == p.y; }
2814  bool operator!= (Point_2D const & p) const { return !(*this == p); }
2815 
2816  bool Equals(Point_2D const & p, int in_tolerance = 32) const {
2817  return Float::Equals(x, p.x, in_tolerance) && Float::Equals(y, p.y, in_tolerance);
2818  }
2819 
2820 
2821  Point_2D & operator*= (F s) { x *= s; y *= s; return *this; }
2822  Point_2D & operator/= (F s) { return operator*= ((F)1 / s); }
2823  Point_2D const operator* (F s) const { return Point_2D (x * s, y * s); }
2824  Point_2D const operator/ (F s) const { return operator* ((F)1 / s); }
2825 
2826  F & operator[] (size_t i) { return (&x)[i]; }
2827  F const & operator[] (size_t i) const { return (&x)[i]; }
2828 
2829  Point_2D & operator+= (Vector_2D<F> const & v);
2830  Point_2D & operator-= (Vector_2D<F> const & v);
2831  Point_2D & operator*= (Vector_2D<F> const & v);
2832  Point_2D & operator/= (Vector_2D<F> const & v);
2833  Point_2D const operator* (Vector_2D<F> const & v) const;
2834  Point_2D const operator/ (Vector_2D<F> const & v) const;
2835 
2836  Vector_2D<F> const operator- (Point_2D const & p) const;
2837 
2838  Point_2D const operator+ (Vector_2D<F> const & v) const;
2839  Point_2D const operator- (Vector_2D<F> const & v) const;
2840 
2841  static HPS_INLINE Point_2D Origin() {return Point_2D (0, 0);};
2842  static HPS_INLINE Point_2D Zero() {return Point_2D (0, 0);}; //-V524
2843 };
2844 
2845 typedef Point_2D<float> Point2D;
2846 typedef Point_2D<double> DPoint2D;
2847 
2848 template <typename F>
2849 HPS_INLINE Point_3D<F>::Point_3D (Point_2D<F> const & that) : x (that.x), y (that.y), z (0) {}
2850 
2851 template <typename F, typename S>
2852 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)); }
2853 
2854 template <typename F>
2855 HPS_INLINE Point_2D<F> Midpoint (Point_2D<F> const & a, Point_2D<F> const & b) {
2856  return Point_2D<F> (a.x + b.x, a.y + b.y) * 0.5f;
2857 }
2858 
2859 template <typename F>
2860 HPS_INLINE Point_2D<F> Midpoint (Point_2D<F> const & a, Point_2D<F> const & b, Point_2D<F> const & c) {
2861  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);
2862 }
2863 
2864 template <typename F>
2865 HPS_INLINE bool Is_Abnormal (Point_2D<F> const & p) {
2866  return Is_Abnormal (p.x) || Is_Abnormal (p.y);
2867 }
2868 
2869 
2870 template <typename F>
2871 class HPS_TEMPLATE_API Vector_3D {
2872  public:
2873  F x;
2874  F y;
2875  F z;
2876 
2877  Vector_3D () {}
2878  Vector_3D (F v1, F v2, F v3) : x (v1), y (v2), z (v3) {}
2879  template <typename D>
2880  explicit Vector_3D (Vector_3D<D> const & that) : x ((F)that.x), y ((F)that.y), z ((F)that.z) {}
2881  explicit Vector_3D(Point_3D<F> const & p) : x(p.x), y(p.y), z(p.z) {}
2882  explicit Vector_3D(Plane_3D<F> const & p);
2883 
2884  explicit Vector_3D (Vector_2D<F> const & that);
2885 
2886  Vector_3D const operator- () const { return Vector_3D (-x, -y, -z); }
2887 
2888  bool operator== (Vector_3D const & v) const {
2889  return Float::match(x, v.x) && Float::match(y, v.y) && Float::match(z, v.z);
2890  }
2891  bool operator!= (Vector_3D const & v) const { return !(*this == v); }
2892 
2893  bool Equals(Vector_3D const & v, int in_tolerance = 32) const {
2894  return Float::Equals(x, v.x, in_tolerance) &&
2895  Float::Equals(y, v.y, in_tolerance) &&
2896  Float::Equals(z, v.z, in_tolerance);
2897  }
2898 
2899  Vector_3D & operator+= (Vector_3D const & v) { x += v.x; y += v.y; z += v.z; return *this; }
2900  Vector_3D & operator-= (Vector_3D const & v) { x -= v.x; y -= v.y; z -= v.z; return *this; }
2901  Vector_3D const operator+ (Vector_3D const & v) const { return Vector_3D (x + v.x, y + v.y, z + v.z); }
2902  Vector_3D const operator- (Vector_3D const & v) const { return Vector_3D (x - v.x, y - v.y, z - v.z); }
2903 
2904  Vector_3D & operator*= (F s) { x *= s; y *= s; z *= s; return *this; }
2905  Vector_3D & operator/= (F s) { return operator*= (1.0f / s); }
2906  Vector_3D const operator* (F s) const { return Vector_3D (x * s, y * s, z * s); }
2907  Vector_3D const operator/ (F s) const { return operator* (1.0f / s); }
2908 
2909  F & operator[] (size_t i) { return (&x)[i]; }
2910  F const & operator[] (size_t i) const { return (&x)[i]; }
2911 
2912  HPS_INLINE double Length () const { return sqrt (LengthSquared()); }
2913 
2914  HPS_INLINE double LengthSquared () const { return (double)x*(double)x + (double)y*(double)y + (double)z*(double)z; }
2915 
2916  HPS_INLINE double Length2D () const { return sqrt (LengthSquared2D()); }
2917 
2918  HPS_INLINE double LengthSquared2D () const { return (double)x*(double)x + (double)y*(double)y;}
2919 
2920  HPS_INLINE Vector_3D & Normalize (bool check_range = false, F epsilon = Float_Traits<F>::Epsilon()) {// not const &; allow V.normalize() *= S;
2921  if (check_range) {
2922  F range = Max (Abs (x), Abs (y), Abs (z));
2923  if (range > F(1.0e10))
2924  operator/= (range);
2925  }
2926 
2927  F len = (F)Length();
2928  if (len > epsilon)
2929  operator/= (len);
2930  else
2931  *this = Zero();
2932  return *this;
2933  }
2934  HPS_INLINE Vector_3D & Normalize (F epsilon) { return Normalize (false, epsilon); }
2935 
2936  HPS_INLINE Vector_3D & Clean_Zeroes (F epsilon = F(1.0e-4)) {
2937  if (Abs(x) < epsilon)
2938  x = 0;
2939  if (Abs(y) < epsilon)
2940  y = 0;
2941  if (Abs(z) < epsilon)
2942  z = 0;
2943  return *this;
2944  }
2945 
2946  HPS_INLINE F Magnitude () const { return Max (Abs(x), Abs(y), Abs(z)); }
2947  HPS_INLINE F Manhattan () const { return Abs(x)+Abs(y)+Abs(z); }
2948 
2949  HPS_INLINE F Dot (Vector_3D const & v) const { return x * v.x + y * v.y + z * v.z; }
2950 
2951  HPS_INLINE Vector_3D Cross (Vector_3D const & v) const {
2952  return Vector_3D (y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x);
2953  }
2954 
2955 
2956  HPS_INLINE Vector_3D Scale (Vector_3D const & v) const {
2957  return Vector_3D (x * v.x, y * v.y, z * v.z);
2958  }
2959 
2960  static HPS_INLINE Vector_3D XAxis() {return Vector_3D (1, 0, 0);};
2961  static HPS_INLINE Vector_3D YAxis() {return Vector_3D (0, 1, 0);};
2962  static HPS_INLINE Vector_3D ZAxis() {return Vector_3D (0, 0, 1);};
2963  static HPS_INLINE Vector_3D Zero() {return Vector_3D (0, 0, 0);};
2964  static HPS_INLINE Vector_3D Unit() {return Vector_3D (1, 1, 1);};
2965 };
2966 
2967 typedef Vector_3D<float> Vector;
2968 typedef Vector_3D<double> DVector;
2969 
2970 
2971 template <typename F, typename S>
2972 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)); }
2973 
2974 template <typename F>
2975 HPS_INLINE bool Is_Abnormal (Vector_3D<F> const & v) {
2976  return Is_Abnormal (v.x) || Is_Abnormal (v.y) || Is_Abnormal (v.z);
2977 }
2978 
2979 
2980 template <typename F>
2981 HPS_INLINE Point_3D<F>::Point_3D(Vector_3D<F> const & v) : x(v.x), y(v.y), z(v.z) {}
2982 
2983 template <typename F>
2984 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; }
2985 template <typename F>
2986 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; }
2987 
2988 template <typename F>
2989 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); }
2990 
2991 template <typename F>
2992 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); }
2993 template <typename F>
2994 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); }
2995 
2996 template <typename F>
2997 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; }
2998 template <typename F>
2999 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; }
3000 template <typename F>
3001 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); }
3002 template <typename F>
3003 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); }
3004 
3005 
3006 
3007 template <typename F>
3008 HPS_INLINE Point_3D<F> Interpolate(Point_3D<F> const & a, Point_3D<F> const & b, float t) {
3009  return a + (b - a) * t;
3010 }
3011 
3012 template <typename F>
3013 HPS_INLINE Vector_3D<F> Interpolate(Vector_3D<F> const & a, Vector_3D<F> const & b, float t) {
3014  return Vector_3D<F>(a + (b - a) * t).Normalize();
3015 }
3016 
3017 
3018 
3019 template <typename F>
3020 HPS_INLINE double PointToPointDistance(Point_3D<F> const & p1, Point_3D<F> const & p2) {
3021  return (p2 - p1).Length();
3022 }
3023 
3024 template <typename F>
3025 HPS_INLINE double PointToPointDistanceSquared(Point_3D<F> const & p1, Point_3D<F> const & p2) {
3026  return (p2 - p1).LengthSquared();
3027 }
3028 
3029 template <typename F>
3030 HPS_INLINE Point_3D<F> Circumcenter(Point_3D<F> const & a, Point_3D<F> const & b, Point_3D<F> const & c) {
3031  F p = static_cast<F>((c - b).LengthSquared());
3032  F q = static_cast<F>((c - a).LengthSquared());
3033  F r = static_cast<F>((b - a).LengthSquared());
3034 
3035  return Point_3D<F>(
3036  (a * (p*(q+r-p)) + (Vector_3D<F>)b * (q*(r+p-q)) + (Vector_3D<F>)c * (r*(p+q-r)))
3037  / (2 * (p*q + p*r + q*r) - (p*p + q*q + r*r)) );
3038 }
3039 
3040 
3041 
3042 template <typename F>
3043 HPS_INLINE bool Normalize(size_t count, Vector_3D<F> * vectors) {
3044  bool success = true;
3045  for (size_t i = 0; i < count; ++i) {
3046  if (vectors->Normalize() == Vector_3D<F>::Zero())
3047  success = false;
3048  vectors++;
3049  }
3050  return success;
3051 }
3052 
3053 
3054 template <typename F> class HPS_TEMPLATE_API Plane_2D;
3055 
3056 template <typename F>
3057 class HPS_TEMPLATE_API Vector_2D {
3058 public:
3059  F x;
3060  F y;
3061 
3062  Vector_2D () {}
3063  Vector_2D (F v1, F v2) : x (v1), y (v2) {}
3064  template <typename D>
3065  explicit Vector_2D (Vector_2D<D> const & that) : x ((F)that.x), y ((F)that.y) {}
3066 
3067  explicit Vector_2D (Vector_3D<F> const & that) : x (that.x), y (that.y) {}
3068  explicit Vector_2D (Point_2D<F> const & p) : x(p.x), y(p.y) {}
3069  explicit Vector_2D (Plane_2D<F> const & p);
3070 
3071  Vector_2D const operator- () const { return Vector_2D (-x, -y); }
3072 
3073  bool operator== (Vector_2D const & v) const {
3074  return Float::match(x, v.x) && Float::match(y, v.y);
3075  }
3076  bool operator!= (Vector_2D const & v) const { return !(*this == v); }
3077 
3078  bool Equals(Vector_2D const & v, int in_tolerance = 32) const {
3079  return Float::Equals(x, v.x, in_tolerance) && Float::Equals(y, v.y, in_tolerance);
3080  }
3081 
3082  Vector_2D & operator+= (Vector_2D const & v) { x += v.x; y += v.y; return *this; }
3083  Vector_2D & operator-= (Vector_2D const & v) { x -= v.x; y -= v.y; return *this; }
3084  Vector_2D const operator+ (Vector_2D const & v) const { return Vector_2D (x + v.x, y + v.y); }
3085  Vector_2D const operator- (Vector_2D const & v) const { return Vector_2D (x - v.x, y - v.y); }
3086 
3087  Vector_2D & operator*= (F s) { x *= s; y *= s; return *this; }
3088  Vector_2D & operator/= (F s) { return operator*= (1.0f / s); }
3089  Vector_2D const operator* (F s) const { return Vector_2D (x * s, y * s); }
3090  Vector_2D const operator/ (F s) const { return operator* (1.0f / s); }
3091 
3092  F & operator[] (size_t i) { return (&x)[i]; }
3093  F const & operator[] (size_t i) const { return (&x)[i]; }
3094 
3095  HPS_INLINE double Length () const { return sqrt (LengthSquared()); }
3096 
3097  HPS_INLINE double LengthSquared () const { return (double)x*(double)x + (double)y*(double)y; }
3098 
3099  HPS_INLINE Vector_2D & Normalize (bool check_range = false, F epsilon = Float_Traits<F>::Epsilon()) {// not const &; allow V.normalize() *= S;
3100  if (check_range) {
3101  F range = Max (Abs (x), Abs (y));
3102  if (range > F(1.0e10))
3103  operator/= (range);
3104  }
3105 
3106  F len = (F)Length();
3107  if (len > epsilon)
3108  operator/= (len);
3109  else
3110  *this = Zero();
3111  return *this;
3112  }
3113  HPS_INLINE Vector_2D & Normalize (F epsilon) { return Normalize (false, epsilon); }
3114 
3115  HPS_INLINE F Magnitude () const { return Max (Abs(x), Abs(y)); }
3116  HPS_INLINE F Manhattan () const { return Abs(x)+Abs(y); }
3117 
3118  HPS_INLINE F Dot (Vector_2D const & v) const { return x * v.x + y * v.y; }
3119 
3120 
3121  HPS_INLINE F Cross (Vector_2D const & v) const {
3122  return x * v.y - y * v.x;
3123  }
3124 
3125  HPS_INLINE Vector_2D Scale (Vector_2D const & v) const {
3126  return Vector_2D (x * v.x, y * v.y);
3127  }
3128 
3129  static HPS_INLINE Vector_2D XAxis() {return Vector_2D (1, 0);};
3130  static HPS_INLINE Vector_2D YAxis() {return Vector_2D (0, 1);};
3131 
3132  static HPS_INLINE Vector_2D Zero() {return Vector_2D (0, 0);};
3133  static HPS_INLINE Vector_2D Unit() {return Vector_2D (1, 1);};
3134 };
3135 
3136 typedef Vector_2D<float> Vector2D;
3138 
3139 template <typename F, typename S>
3140 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)); }
3141 
3142 template <typename F>
3143 HPS_INLINE bool Is_Abnormal (Vector_2D<F> const & v) {
3144  return Is_Abnormal (v.x) || Is_Abnormal (v.y);
3145 }
3146 
3147 
3148 template <typename F>
3149 HPS_INLINE Vector_3D<F>::Vector_3D (Vector_2D<F> const & that) : x (that.x), y (that.y), z(0) {}
3150 
3151 template <typename F>
3152 HPS_INLINE Point_3D<F>::Point_3D(Vector_2D<F> const & v) : x(v.x), y(v.y), z(0) {}
3153 
3154 template <typename F>
3155 HPS_INLINE Point_3D<F> & Point_3D<F>::operator+= (Vector_2D<F> const & v) { x += v.x; y += v.y; return *this; }
3156 template <typename F>
3157 HPS_INLINE Point_3D<F> & Point_3D<F>::operator-= (Vector_2D<F> const & v) { x -= v.x; y -= v.y; return *this; }
3158 
3159 template <typename F>
3160 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); }
3161 template <typename F>
3162 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); }
3163 
3164 template <typename F>
3165 HPS_INLINE Point_3D<F> & Point_3D<F>::operator*= (Vector_2D<F> const & v) { x *= v.x; y *= v.y; return *this; }
3166 template <typename F>
3167 HPS_INLINE Point_3D<F> & Point_3D<F>::operator/= (Vector_2D<F> const & v) { x /= v.x; y /= v.y; return *this; }
3168 
3169 template <typename F>
3170 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); }
3171 template <typename F>
3172 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); }
3173 
3174 
3175 template <typename F>
3176 HPS_INLINE Point_2D<F> & Point_2D<F>::operator+= (Vector_2D<F> const & v) { x += v.x; y += v.y; return *this; }
3177 template <typename F>
3178 HPS_INLINE Point_2D<F> & Point_2D<F>::operator-= (Vector_2D<F> const & v) { x -= v.x; y -= v.y; return *this; }
3179 
3180 template <typename F>
3181 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); }
3182 
3183 template <typename F>
3184 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); }
3185 template <typename F>
3186 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); }
3187 
3188 template <typename F>
3189 HPS_INLINE Point_2D<F> & Point_2D<F>::operator*= (Vector_2D<F> const & v) { x *= v.x; y *= v.y; return *this; }
3190 template <typename F>
3191 HPS_INLINE Point_2D<F> & Point_2D<F>::operator/= (Vector_2D<F> const & v) { x /= v.x; y /= v.y; return *this; }
3192 template <typename F>
3193 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); }
3194 template <typename F>
3195 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); }
3196 
3197 
3198 
3199 
3200 
3201 template <typename F>
3202 class HPS_TEMPLATE_API Plane_3D {
3203  public:
3204  F a;
3205  F b;
3206  F c;
3207  F d;
3208 
3209  Plane_3D () {}
3210  Plane_3D (F v1, F v2, F v3, F v4) : a (v1), b (v2), c (v3), d (v4) {}
3211  Plane_3D (Vector_3D<F> const & v, F f = 0) : a (v.x), b (v.y), c (v.z), d (f) {}
3212  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)) {}
3213  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)) {}
3214  template <typename D>
3215  explicit Plane_3D (Plane_3D<D> const & that) : a ((F)that.a), b ((F)that.b), c ((F)that.c), d ((F)that.d) {}
3216 
3217  Plane_3D (size_t count, Point_3D<F> const * points) {
3218  if (count >= 3) {
3219  // The 3 coefficients A, B, and C are proportional to the areas of the
3220  // projections of the polygon onto the yz, zx, and xy planes, respectively.
3221 
3222  // run around the polygon, collecting trapezoidal areas
3223  // a "center" point is also collected, to make the plane 'd' slightly more "valid" when the polygon is non-planar.
3224 
3225  // take care of the swing point first
3226  Point_3D<F> const * p0 = &points[count-1];
3227 
3229  Vector_3D<F> normal = Vector_3D<F>::Zero();
3230 
3231  for (size_t i=0; i<count; ++i) {
3232  Point_3D<F> const * p1 = &points[i];
3233 
3234  normal.x += (p0->y + p1->y) * (p1->z - p0->z);
3235  normal.y += (p0->z + p1->z) * (p1->x - p0->x);
3236  normal.z += (p0->x + p1->x) * (p1->y - p0->y);
3237 
3238  ctr += Vector_3D<double>(Vector_3D<F>(points[i]));
3239 
3240  p0 = p1;
3241  }
3242 
3243  // ("should" always be != 0)
3244  if (normal.Normalize() != Vector_3D<F>::Zero()) {
3245  /* finish finding the average */
3246  double inv_count = 1.0 / (double)count;
3247  ctr *= inv_count;
3248 
3249  *this = Plane_3D(normal, Point_3D<F>(ctr));
3250  return;
3251  }
3252  }
3253 
3254  *this = Plane_3D::Zero();
3255  }
3256 
3257 
3258  Plane_3D const operator- () const { return Plane_3D (-a, -b, -c, -d); }
3259 
3260  bool operator== (Plane_3D const & p) const { return a == p.a && b == p.b && c == p.c && d == p.d; }
3261  bool operator!= (Plane_3D const & p) const { return !(*this == p); }
3262 
3263  F & operator[] (size_t i) { return (&a)[i]; }
3264  F const & operator[] (size_t i) const { return (&a)[i]; }
3265 
3266  HPS_INLINE bool Equals(Plane_3D const & p, int in_tolerance = 32) const {
3267  return Float::Equals(a, p.a, in_tolerance) && Float::Equals(b, p.b, in_tolerance) &&
3268  Float::Equals(c, p.c, in_tolerance) && Float::Equals(d, p.d, in_tolerance);
3269  }
3270 
3271  Plane_3D & Normalize (F epsilon = Float_Traits<F>::Epsilon()) { // not const &; allow V.normalize() *= S;
3272  F len = (F)Vector_3D<F>(*this).Length();
3273  if (len > epsilon)
3274  operator/= (len);
3275  else
3276  *this = Zero();
3277  return *this;
3278  }
3279 
3280  Point_3D<F> IntersectLineSegment(Point_3D<F> const & p1, Point_3D<F> const & p2, float eps = 1e-5f) const {
3281  F val1 = Abs (a * p1.x + b * p1.y + c * p1.z + d);
3282  F val2 = Abs (a * p2.x + b * p2.y + c * p2.z + d);
3283 
3284  if (val1 >= eps) {
3285  return Point_3D<F> (((val1 * p2.x) + (val2 * p1.x)) / (val1 + val2),
3286  ((val1 * p2.y) + (val2 * p1.y)) / (val1 + val2),
3287  ((val1 * p2.z) + (val2 * p1.z)) / (val1 + val2));
3288  }
3289  else
3290  return p1;
3291  }
3292 
3293  Point_3D<F> IntersectLineSegment2(Point_3D<F> const & p1, Point_3D<F> const & p2) const {
3294  F u = (a * p1.x + b * p1.y + c * p1.z + d) /
3295  (a * (p1.x - p2.x) + b * (p1.y - p2.y) + c * (p1.z - p2.z));
3296 
3297  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));
3298  }
3299 
3300  static HPS_INLINE Plane_3D Zero() {return Plane_3D (0.0f, 0.0f, 0.0f, 0.0f);};
3301 
3302 
3303  private:
3304  Plane_3D & operator*= (F s) { a *= s; b *= s; c *= s; d *= s; return *this; }
3305  Plane_3D & operator/= (F s) { return operator*= ((F)1.0 / s); }
3306  Plane_3D const operator* (F s) const { return Plane_3D (a * s, b * s, c * s, d * s); }
3307  Plane_3D const operator/ (F s) const { return operator* ((F)1.0 / s); }
3308 };
3309 
3310 typedef Plane_3D<float> Plane;
3311 typedef Plane_3D<double> DPlane;
3312 
3313 
3314 template <typename F>
3315 HPS_INLINE bool Is_Abnormal (Plane_3D<F> const & p) {
3316  return Is_Abnormal (p.a) || Is_Abnormal (p.b) || Is_Abnormal (p.c) || Is_Abnormal (p.d);
3317 }
3318 
3319 
3320 template <typename F>
3321 HPS_INLINE F operator* (Plane_3D<F> const & plane, Point_3D<F> const & point) {
3322  return plane.a * point.x + plane.b * point.y + plane.c * point.z + plane.d;
3323 }
3324 template <typename F>
3325 HPS_INLINE F operator* (Point_3D<F> const & point, Plane_3D<F> const & plane) {
3326  return plane * point;
3327 }
3328 
3329 template <typename F>
3330 HPS_INLINE Plane_3D<F> Interpolate(Plane_3D<F> const & a, Plane_3D<F> const & b, float t) {
3331  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);
3332 }
3333 
3334 template <typename F>
3335 Vector_3D<F>::Vector_3D(Plane_3D<F> const & p) : x(p.a), y(p.b), z(p.c) {}
3336 
3337 
3338 
3339 
3340 
3341 
3342 template <typename F>
3343 class HPS_TEMPLATE_API Plane_2D {
3344 public:
3345  F a;
3346  F b;
3347  F c;
3348 
3349  Plane_2D () {}
3350  Plane_2D (F v1, F v2, F v3) : a (v1), b (v2), c (v3) {}
3351  Plane_2D (Vector_2D<F> const & v, F f = 0) : a (v.x), b (v.y), c (f) {}
3352  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)) {}
3353  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)) {}
3354  template <typename D>
3355  explicit Plane_2D (Plane_2D<D> const & that) : a ((F)that.a), b ((F)that.b), c ((F)that.c) {}
3356 
3357  Plane_2D const operator- () const { return Plane_2D (-a, -b, -c); }
3358 
3359  bool operator== (Plane_2D const & p) const { return a == p.a && b == p.b && c == p.c; }
3360  bool operator!= (Plane_2D const & p) const { return !(*this == p); }
3361 
3362  F & operator[] (size_t i) { return (&a)[i]; }
3363  F const & operator[] (size_t i) const { return (&a)[i]; }
3364 
3365  HPS_INLINE bool Equals(Plane_2D const & p, int in_tolerance = 32) const {
3366  return Float::Equals(a, p.a, in_tolerance) && Float::Equals(b, p.b, in_tolerance) && Float::Equals(c, p.c, in_tolerance);
3367  }
3368 
3369  Plane_2D & Normalize (F epsilon = Float_Traits<F>::Epsilon()) { // not const &; allow V.Normalize() *= S;
3370  F len = (F)Vector_2D<F>(*this).Length();
3371  if (len > epsilon)
3372  operator/= (len);
3373  else
3374  *this = Zero();
3375  return *this;
3376  }
3377 
3378  static HPS_INLINE Plane_2D Zero() {return Plane_2D (0.0f, 0.0f, 0.0f);};
3379 
3380 
3381 private:
3382  Plane_2D & operator*= (F s) { a *= s; b *= s; c *= s; return *this; }
3383  Plane_2D & operator/= (F s) { return operator*= ((F)1.0 / s); }
3384  Plane_2D const operator* (F s) const { return Plane_2D (a * s, b * s, c * s); }
3385  Plane_2D const operator/ (F s) const { return operator* ((F)1.0 / s); }
3386 };
3387 
3388 typedef Plane_2D<float> Plane2D;
3389 typedef Plane_2D<double> DPlane2D;
3390 
3391 
3392 template <typename F>
3393 HPS_INLINE bool Is_Abnormal (Plane_2D<F> const & p) {
3394  return Is_Abnormal (p.a) || Is_Abnormal (p.b) || Is_Abnormal (p.c);
3395 }
3396 
3397 
3398 template <typename F>
3399 HPS_INLINE F operator* (Plane_2D<F> const & plane, Point_2D<F> const & point) {
3400  return plane.a * point.x + plane.b * point.y + plane.c;
3401 }
3402 template <typename F>
3403 HPS_INLINE F operator* (Point_3D<F> const & point, Plane_2D<F> const & plane) {
3404  return plane * point;
3405 }
3406 
3407 template <typename F>
3408 HPS_INLINE Plane_2D<F> Interpolate(Plane_2D<F> const & a, Plane_2D<F> const & b, float t) {
3409  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);
3410 }
3411 
3412 template <typename F>
3413 Vector_2D<F>::Vector_2D(Plane_2D<F> const & p) : x(p.a), y(p.b) {}
3414 
3415 
3416 
3417 
3418 struct Rectangle;
3419 
3420 struct HPS_API IntRectangle {
3421  int left;
3422  int right;
3423  int bottom;
3424  int top;
3425 
3426  IntRectangle()
3427  : left(std::numeric_limits<int>::max()), right(std::numeric_limits<int>::min()),
3428  bottom(std::numeric_limits<int>::max()), top(std::numeric_limits<int>::min()) {}
3429 
3430  IntRectangle(int in_left, int in_right, int in_bottom, int in_top)
3431  : left(in_left), right(in_right), bottom(in_bottom), top(in_top) {}
3432 
3433  IntRectangle(IntRectangle const & that)
3434  : left(that.left), right(that.right), bottom(that.bottom), top(that.top) {}
3435 
3436  explicit IntRectangle(Rectangle const & that);
3437 
3438  bool operator==(IntRectangle const & rect) const {
3439  return (left == rect.left && right == rect.right && bottom == rect.bottom && top == rect.top);
3440  }
3441 
3442  bool operator!=(IntRectangle const & rect) const {
3443  return !(*this == rect);
3444  }
3445 
3446  HPS_INLINE int PixelWidth() const {
3447  return right - left + 1;
3448  }
3449 
3450  HPS_INLINE int PixelHeight() const {
3451  return top - bottom + 1;
3452  }
3453 
3454  HPS_INLINE int Width() const {
3455  return right - left;
3456  }
3457 
3458  HPS_INLINE int Height() const {
3459  return top - bottom;
3460  }
3461 
3462  HPS_INLINE int Area() const {
3463  return Width() * Height();
3464  }
3465 
3466  HPS_INLINE float Aspect() const {
3467  return (float)Height() / (float)Width();
3468  }
3469 
3470  HPS_INLINE Point2D Center() const {
3471  return Point2D((float)(left + right) * 0.5f, (float)(bottom + top) * 0.5f);
3472  }
3473 
3474  HPS_INLINE bool Intersecting(IntRectangle const & rect) const {
3475  return right >= rect.left && left <= rect.right && top >= rect.bottom && bottom <= rect.top;
3476  }
3477 
3478  HPS_INLINE bool Contains(IntRectangle const & rect) const {
3479  return (left <= rect.left && right >= rect.right && bottom <= rect.bottom && top >= rect.top);
3480  }
3481 
3482  HPS_INLINE IntRectangle & Expand(int border) {
3483  left -= border;
3484  right += border;
3485  bottom -= border;
3486  top += border;
3487  return *this;
3488  }
3489 
3490  HPS_INLINE IntRectangle & Expand(IntRectangle const & rect) {
3491  left -= rect.left;
3492  right += rect.right;
3493  bottom -= rect.bottom;
3494  top += rect.top;
3495  return *this;
3496  }
3497 
3498  HPS_INLINE IntRectangle & Contract(int border) {
3499  left += border;
3500  right -= border;
3501  bottom += border;
3502  top -= border;
3503  return *this;
3504  }
3505 
3506  HPS_INLINE IntRectangle & Contract(IntRectangle const & rect) {
3507  left += rect.left;
3508  right -= rect.right;
3509  bottom += rect.bottom;
3510  top -= rect.top;
3511  return *this;
3512  }
3513 
3514  HPS_INLINE IntRectangle & Intersect(IntRectangle const & rect) {
3515  left = Max(left, rect.left);
3516  right = Min(right, rect.right);
3517  bottom = Max(bottom, rect.bottom);
3518  top = Min(top, rect.top);
3519  return *this;
3520  }
3521 
3522  HPS_INLINE IntRectangle & Union(IntRectangle const & rect) {
3523  left = Min(left, rect.left);
3524  right = Max(right, rect.right);
3525  bottom = Min(bottom, rect.bottom);
3526  top = Max(top, rect.top);
3527  return *this;
3528  }
3529 
3530 
3531  static HPS_INLINE IntRectangle Invalid() {
3532  return IntRectangle();
3533  }
3534 
3535  static HPS_INLINE IntRectangle Zero() {
3536  return IntRectangle(0, 0, 0, 0);
3537  }
3538 
3539 };
3540 
3541 HPS_INLINE IntRectangle Expand(IntRectangle const & a, IntRectangle const & border) {
3542  IntRectangle temp = a;
3543  return temp.Expand(border);
3544 }
3545 
3546 HPS_INLINE IntRectangle Expand(IntRectangle const & a, int border) {
3547  IntRectangle temp = a;
3548  return temp.Expand(border);
3549 }
3550 
3551 HPS_INLINE IntRectangle Contract(IntRectangle const & a, int border) {
3552  IntRectangle temp = a;
3553  return temp.Contract(border);
3554 }
3555 
3556 HPS_INLINE IntRectangle Contract(IntRectangle const & a, IntRectangle const & border) {
3557  IntRectangle temp = a;
3558  return temp.Contract(border);
3559 }
3560 
3561 HPS_INLINE IntRectangle Intersect(IntRectangle const & a, IntRectangle const & b) {
3562  IntRectangle temp = a;
3563  return temp.Intersect(b);
3564 }
3565 
3566 HPS_INLINE IntRectangle Union(IntRectangle const & a, IntRectangle const & b) {
3567  IntRectangle temp = a;
3568  return temp.Union(b);
3569 }
3570 
3571 struct HPS_API Rectangle {
3572  float left;
3573  float right;
3574  float bottom;
3575  float top;
3576 
3577  Rectangle()
3578  : left(std::numeric_limits<float>::max()), right(-std::numeric_limits<float>::max()),
3579  bottom(std::numeric_limits<float>::max()), top(-std::numeric_limits<float>::max()) {}
3580 
3581  Rectangle(float in_left, float in_right, float in_bottom, float in_top)
3582  : left(in_left), right(in_right), bottom(in_bottom), top(in_top) {}
3583 
3584  Rectangle(Rectangle const & that)
3585  : left(that.left), right(that.right), bottom(that.bottom), top(that.top) {}
3586 
3587  explicit Rectangle(IntRectangle const & that)
3588  : left((float)that.left), right((float)that.right), bottom((float)that.bottom), top((float)that.top) {}
3589 
3590  HPS_INLINE Rectangle(size_t count, Point const * points) {
3591  left = points->x;
3592  right = points->x;
3593  top = points->y;
3594  bottom = points->y;
3595  --count;
3596  if (count > 0) {
3597  ++points;
3598  Merge(count, points);
3599  }
3600  }
3601 
3602  HPS_INLINE Rectangle(size_t count, Point2D const * points) {
3603  left = points->x;
3604  right = points->x;
3605  top = points->y;
3606  bottom = points->y;
3607  --count;
3608  if (count > 0) {
3609  ++points;
3610  Merge(count, points);
3611  }
3612  }
3613 
3614  HPS_INLINE float Width() const {
3615  return right - left;
3616  }
3617 
3618  HPS_INLINE float Height() const {
3619  return top - bottom;
3620  }
3621 
3622  HPS_INLINE float Area() const {
3623  return Width() * Height();
3624  }
3625 
3626  HPS_INLINE float Aspect() const {
3627  return Height() / Width();
3628  }
3629 
3630  HPS_INLINE Point2D Center() const {
3631  return Point2D((left + right) * 0.5f, (bottom + top) * 0.5f);
3632  }
3633 
3634  HPS_INLINE void Merge(size_t count, Point const * points) {
3635 
3636  while (count > 1) {
3637  if (points[0].x > points[1].x) {
3638  Float::replace_if_smaller(left, points[1].x);
3639  Float::replace_if_larger(right, points[0].x);
3640  }
3641  else {
3642  Float::replace_if_smaller(left, points[0].x);
3643  Float::replace_if_larger(right, points[1].x);
3644  }
3645 
3646  if (points[0].y > points[1].y) {
3647  Float::replace_if_smaller(bottom, points[1].y);
3648  Float::replace_if_larger(top, points[0].y);
3649  }
3650  else {
3651  Float::replace_if_smaller(bottom, points[0].y);
3652  Float::replace_if_larger(top, points[1].y);
3653  }
3654 
3655  points += 2;
3656  count -= 2;
3657  }
3658 
3659  if (count > 0)
3660  Merge(*points);
3661  }
3662 
3663  HPS_INLINE void Merge(Point const & point) {
3664  Float::replace_if_smaller(left, point.x);
3665  Float::replace_if_smaller(bottom, point.y);
3666  Float::replace_if_larger(right, point.x);
3667  Float::replace_if_larger(top, point.y);
3668  }
3669 
3670  HPS_INLINE void Merge(size_t count, Point2D const * points) {
3671 
3672  while (count > 1) {
3673  if (points[0].x > points[1].x) {
3674  Float::replace_if_smaller(left, points[1].x);
3675  Float::replace_if_larger(right, points[0].x);
3676  }
3677  else {
3678  Float::replace_if_smaller(left, points[0].x);
3679  Float::replace_if_larger(right, points[1].x);
3680  }
3681 
3682  if (points[0].y > points[1].y) {
3683  Float::replace_if_smaller(bottom, points[1].y);
3684  Float::replace_if_larger(top, points[0].y);
3685  }
3686  else {
3687  Float::replace_if_smaller(bottom, points[0].y);
3688  Float::replace_if_larger(top, points[1].y);
3689  }
3690 
3691  points += 2;
3692  count -= 2;
3693  }
3694 
3695  if (count > 0)
3696  Merge(*points);
3697  }
3698 
3699  HPS_INLINE void Merge(Point2D const & point) {
3700  Float::replace_if_smaller(left, point.x);
3701  Float::replace_if_smaller(bottom, point.y);
3702  Float::replace_if_larger(right, point.x);
3703  Float::replace_if_larger(top, point.y);
3704  }
3705 
3706  HPS_INLINE bool operator==(Rectangle const & rect) const {
3707  return (left == rect.left && right == rect.right && bottom == rect.bottom && top == rect.top);
3708  }
3709 
3710  HPS_INLINE bool operator!=(Rectangle const & rect) const {
3711  return !(*this == rect);
3712  }
3713 
3714  HPS_INLINE bool Equals(Rectangle const & rect, int in_tolerance = 32) const {
3715  return Float::Equals(left, rect.left, in_tolerance) &&
3716  Float::Equals(right, rect.right, in_tolerance) &&
3717  Float::Equals(top, rect.top, in_tolerance) &&
3718  Float::Equals(bottom, rect.bottom, in_tolerance);
3719  }
3720 
3721  HPS_INLINE bool Intersecting(Rectangle const & rect) const {
3722  return right >= rect.left && left <= rect.right && top >= rect.bottom && bottom <= rect.top;
3723  }
3724 
3725  HPS_INLINE bool Contains(Point const & contained) const {
3726  return !(contained.x < left || contained.x > right || contained.y < bottom || contained.y > top);
3727  }
3728 
3729  HPS_INLINE bool Contains(Point2D const & contained) const {
3730  return !(contained.x < left || contained.x > right || contained.y < bottom || contained.y > top);
3731  }
3732 
3733  HPS_INLINE bool Contains(Rectangle const & rect) {
3734  return (left <= rect.left && right >= rect.right && bottom <= rect.bottom && top >= rect.top);
3735  }
3736 
3737  HPS_INLINE bool Contains(Rectangle const & rect, float epsilon) {
3738  return (left <= rect.left + epsilon && right >= rect.right - epsilon &&
3739  bottom <= rect.bottom + epsilon && top >= rect.top - epsilon);
3740  }
3741 
3742  HPS_INLINE Rectangle & Expand(float border) {
3743  left -= border;
3744  right += border;
3745  bottom -= border;
3746  top += border;
3747  return *this;
3748  }
3749 
3750  HPS_INLINE Rectangle & Expand(int border) {
3751  Expand((float)border);
3752  return *this;
3753  }
3754 
3755  HPS_INLINE Rectangle & Expand(Rectangle const & rect) {
3756  left -= rect.left;
3757  right += rect.right;
3758  bottom -= rect.bottom;
3759  top += rect.top;
3760  return *this;
3761  }
3762 
3763  HPS_INLINE Rectangle & Contract(int border) {
3764  left += border;
3765  right -= border;
3766  bottom += border;
3767  top -= border;
3768  return *this;
3769  }
3770 
3771  HPS_INLINE Rectangle & Contract(Rectangle const & rect) {
3772  left += rect.left;
3773  right -= rect.right;
3774  bottom += rect.bottom;
3775  top -= rect.top;
3776  return *this;
3777  }
3778 
3779  HPS_INLINE Rectangle & Intersect(Rectangle const & rect) {
3780  left = Max(left, rect.left);
3781  right = Min(right, rect.right);
3782  bottom = Max(bottom, rect.bottom);
3783  top = Min(top, rect.top);
3784  return *this;
3785  }
3786 
3787  HPS_INLINE Rectangle & Union(Rectangle const & rect) {
3788  left = Min(left, rect.left);
3789  right = Max(right, rect.right);
3790  bottom = Min(bottom, rect.bottom);
3791  top = Max(top, rect.top);
3792  return *this;
3793  }
3794 
3795  HPS_INLINE Rectangle & Inscribe_Scope(Rectangle const & scope) {
3796  float scale = (scope.right - scope.left) * 0.5f;
3797  float trans = (scope.right + scope.left) * 0.5f;
3798 
3799  left = left * scale + trans;
3800  right = right * scale + trans;
3801 
3802  scale = (scope.top - scope.bottom) * 0.5f;
3803  trans = (scope.top + scope.bottom) * 0.5f;
3804 
3805  bottom = bottom * scale + trans;
3806  top = top * scale + trans;
3807  return *this;
3808  }
3809 
3810  HPS_INLINE Rectangle & Circumscribe_Scope(Rectangle const & scope) {
3811  float tmp = 2.0f/(scope.right - scope.left);
3812  right = (right - scope.left) * tmp - 1.0f;
3813  left = (left - scope.left) * tmp - 1.0f;
3814 
3815  tmp = 2.0f/(scope.top - scope.bottom);
3816  top = (top - scope.bottom) * tmp - 1.0f;
3817  bottom = (bottom - scope.bottom) * tmp - 1.0f;
3818  return *this;
3819  }
3820 
3821  static HPS_INLINE Rectangle FullScope() {
3822  return Rectangle(-1.0f, 1.0f, -1.0f, 1.0f);
3823  }
3824 
3825  static HPS_INLINE Rectangle InvalidScope() {
3826  return Rectangle(1.0f, -1.0f, 1.0f, -1.0f);
3827  }
3828 
3829  static HPS_INLINE Rectangle Zero() {
3830  return Rectangle(0, 0, 0, 0);
3831  }
3832 
3833 };
3834 
3835 
3836 HPS_INLINE IntRectangle Floor(Rectangle const & a) {
3837  IntRectangle temp;
3838  temp.left = Floor (a.left);
3839  temp.right = Floor (a.right);
3840  temp.bottom = Floor (a.bottom);
3841  temp.top = Floor (a.top);
3842  return temp;
3843 }
3844 
3845 HPS_INLINE Rectangle Expand(Rectangle const & a, Rectangle const & border) {
3846  Rectangle temp = a;
3847  return temp.Expand(border);
3848 }
3849 
3850 HPS_INLINE Rectangle Expand(Rectangle const & a, float border) {
3851  Rectangle temp = a;
3852  return temp.Expand(border);
3853 }
3854 
3855 HPS_INLINE Rectangle Contract(Rectangle const & a, int border) {
3856  Rectangle temp = a;
3857  return temp.Contract(border);
3858 }
3859 
3860 HPS_INLINE Rectangle Contract(Rectangle const & a, Rectangle const & border) {
3861  Rectangle temp = a;
3862  return temp.Contract(border);
3863 }
3864 
3865 HPS_INLINE Rectangle Intersect(Rectangle const & a, Rectangle const & b) {
3866  Rectangle temp = a;
3867  return temp.Intersect(b);
3868 }
3869 
3870 HPS_INLINE Rectangle Union(Rectangle const & a, Rectangle const & b) {
3871  Rectangle temp = a;
3872  return temp.Union(b);
3873 }
3874 
3875 HPS_INLINE Rectangle Inscribe_Scope(Rectangle const & a, Rectangle const & scope) {
3876  Rectangle temp = a;
3877  return temp.Inscribe_Scope(scope);
3878 }
3879 
3880 HPS_INLINE Rectangle Circumscribe_Scope(Rectangle const & a, Rectangle const & scope) {
3881  Rectangle temp = a;
3882  return temp.Circumscribe_Scope(scope);
3883 }
3884 
3885 HPS_INLINE IntRectangle::IntRectangle(Rectangle const & that)
3886  : left ((int)that.left), right ((int)that.right), bottom ((int)that.bottom), top ((int)that.top) {}
3887 
3888 
3889 
3890 
3891 template <typename F>
3892 struct Sphere_3D;
3893 
3894 template <typename F>
3895 struct HPS_TEMPLATE_API Cuboid_3D {
3900 
3901 
3905  Cuboid_3D () : min (Limit_Point()), max (-Limit_Point()) {}
3906 
3907 
3912  template <typename D>
3913  explicit Cuboid_3D (Cuboid_3D<D> const & that) : min (Point_3D<F>(that.min)), max (Point_3D<F>(that.max)) {}
3914 
3915 
3920  Cuboid_3D (Sphere_3D<F> const & that);
3921 
3927  Cuboid_3D (Point_3D<F> const & in_min, Point_3D<F> const & in_max) : min (in_min), max (in_max) {}
3928 
3934  Cuboid_3D (size_t count, Point_3D<F> const * points) {
3935  if (count == 0) {
3936  min = Limit_Point();
3937  max = -Limit_Point();
3938  return;
3939  }
3940  min = max = *points++;
3941  if (--count > 0)
3942  Merge(count, points);
3943  }
3944 
3951  template <typename T>
3952  Cuboid_3D (size_t count, T const * indices, Point_3D<F> const * points) {
3953  if (count == 0) {
3954  min = Limit_Point();
3955  max = -Limit_Point();
3956  return;
3957  }
3958  min = max = points[*indices++];
3959  if (--count > 0)
3960  Merge(count, indices, points);
3961  }
3962 
3967  Cuboid_3D (Rectangle const & that) : min (Point_3D<F>(that.left, that.bottom, 0)), max (Point_3D<F>(that.right, that.top, 0)) {}
3968 
3972  HPS_INLINE bool IsValid() const {
3973  return min.x <= max.x && min.y <= max.y && min.z <= max.z;
3974  }
3975 
3979  static HPS_INLINE Cuboid_3D Invalid() {return Cuboid_3D ();};
3980 
3984  void Invalidate() {min = Limit_Point(); max = -Limit_Point();}
3985 
3990  HPS_INLINE bool operator== (Cuboid_3D const & cuboid) const { return (min == cuboid.min && max == cuboid.max); }
3991 
3996  HPS_INLINE bool operator!= (Cuboid_3D const & cuboid) const { return !(*this == cuboid); }
3997 
4002  HPS_INLINE void Generate_Cuboid_Points (Point_3D<F> * points) const {
4003  points[0] = Point_3D<F> (min.x, min.y, min.z);
4004  points[1] = Point_3D<F> (min.x, min.y, max.z);
4005  points[2] = Point_3D<F> (min.x, max.y, min.z);
4006  points[3] = Point_3D<F> (min.x, max.y, max.z);
4007  points[4] = Point_3D<F> (max.x, min.y, min.z);
4008  points[5] = Point_3D<F> (max.x, min.y, max.z);
4009  points[6] = Point_3D<F> (max.x, max.y, min.z);
4010  points[7] = Point_3D<F> (max.x, max.y, max.z);
4011  }
4012 
4016  HPS_INLINE Vector_3D<F> Diagonal() const { return max - min; }
4017 
4021  HPS_INLINE F Volume () const { return (max.x - min.x) * (max.y - min.y) * (max.z - min.z); }
4022 
4028  HPS_INLINE bool Intersecting (Cuboid_3D const & cuboid) const {
4029  return max.x >= cuboid.min.x && min.x <= cuboid.max.x &&
4030  max.y >= cuboid.min.y && min.y <= cuboid.max.y &&
4031  max.z >= cuboid.min.z && min.z <= cuboid.max.z;
4032  }
4033 
4039  HPS_INLINE bool Intersecting (Cuboid_3D const & cuboid, F const allowance) const {
4040  return max.x + allowance >= cuboid.min.x && min.x - allowance <= cuboid.max.x &&
4041  max.y + allowance >= cuboid.min.y && min.y - allowance <= cuboid.max.y &&
4042  max.z + allowance >= cuboid.min.z && min.z - allowance <= cuboid.max.z;
4043  }
4044 
4051  HPS_INLINE bool Intersecting (int dimension, Cuboid_3D const & cuboid) const {
4052  //ASSERT (0 <= dimension && dimension <= 2);
4053  return max[dimension] >= cuboid.min[dimension] && min[dimension] <= cuboid.max[dimension];
4054  }
4055 
4063  HPS_INLINE bool Intersecting (int dimension, Cuboid_3D const & cuboid, F const allowance) const {
4064  //ASSERT (0 <= dimension && dimension <= 2);
4065  return max[dimension] + allowance >= cuboid.min[dimension] && min[dimension] - allowance <= cuboid.max[dimension];
4066  }
4067 
4074  HPS_INLINE bool Intersecting (Point_3D<F> const & start, Vector_3D<F> const & direction) const {
4075  return LineIntersecting(start, direction, true);
4076  }
4077 
4084  HPS_INLINE bool Intersecting (Point_3D<F> const & point1, Point_3D<F> const & point2) const {
4085  Vector_3D<F> const direction = point2 - point1;
4086  return LineIntersecting(point1, direction, false);
4087  }
4088 
4094  HPS_INLINE void Merge(Cuboid_3D const & cuboid) {
4095  Float::replace_if_smaller(min.x, cuboid.min.x);
4096  Float::replace_if_smaller(min.y, cuboid.min.y);
4097  Float::replace_if_smaller(min.z, cuboid.min.z);
4098  Float::replace_if_larger(max.x, cuboid.max.x);
4099  Float::replace_if_larger(max.y, cuboid.max.y);
4100  Float::replace_if_larger(max.z, cuboid.max.z);
4101  }
4102 
4108  HPS_INLINE void Merge(Sphere_3D<F> const & sphere) { Merge (Cuboid_3D (sphere)); }
4109 
4115  HPS_INLINE void Merge(Point_3D<F> const & point) {
4116  Float::replace_if_smaller(min.x, point.x);
4117  Float::replace_if_smaller(min.y, point.y);
4118  Float::replace_if_smaller(min.z, point.z);
4119  Float::replace_if_larger(max.x, point.x);
4120  Float::replace_if_larger(max.y, point.y);
4121  Float::replace_if_larger(max.z, point.z);
4122  }
4123 
4130  void Merge(size_t count, Point_3D<F> const * points) {
4131  while (count > 1) {
4132  merge2(points[0], points[1]);
4133  points += 2;
4134  count -= 2;
4135  }
4136 
4137  if (count > 0)
4138  Merge(*points);
4139  }
4140 
4148  template <typename T>
4149  void Merge(size_t count, T const * indices, Point_3D<F> const * points) {
4150  while (count > 1) {
4151  T i1 = *indices++;
4152  T i2 = *indices++;
4153  merge2(points[i1], points[i2]);
4154  count -= 2;
4155  }
4156 
4157  if (count > 0)
4158  Merge(points[*indices]);
4159  }
4160 
4166  HPS_INLINE bool Contains(Cuboid_3D const & contained) const {
4167  return (contained.min.x >= min.x &&
4168  contained.min.y >= min.y &&
4169  contained.min.z >= min.z &&
4170  contained.max.x <= max.x &&
4171  contained.max.y <= max.y &&
4172  contained.max.z <= max.z);
4173  }
4174 
4180  HPS_INLINE bool Contains(Point_3D<F> const & contained) const {
4181  return (contained.x >= min.x &&
4182  contained.y >= min.y &&
4183  contained.z >= min.z &&
4184  contained.x <= max.x &&
4185  contained.y <= max.y &&
4186  contained.z <= max.z);
4187  }
4188 
4195  HPS_INLINE bool Contains(Point_3D<F> const & contained, F epsilon) const {
4196  return (contained.x >= min.x - epsilon &&
4197  contained.y >= min.y - epsilon &&
4198  contained.z >= min.z - epsilon &&
4199  contained.x <= max.x + epsilon &&
4200  contained.y <= max.y + epsilon &&
4201  contained.z <= max.z + epsilon);
4202  }
4203 
4209  HPS_INLINE Cuboid_3D & Intersect(Cuboid_3D const & cuboid) {
4210  Float::replace_if_larger(min.x, cuboid.min.x);
4211  Float::replace_if_larger(min.y, cuboid.min.y);
4212  Float::replace_if_larger(min.z, cuboid.min.z);
4213  Float::replace_if_smaller(max.x, cuboid.max.x);
4214  Float::replace_if_smaller(max.y, cuboid.max.y);
4215  Float::replace_if_smaller(max.z, cuboid.max.z);
4216  return *this;
4217  }
4218 
4224  HPS_INLINE Cuboid_3D & Union(Cuboid_3D const & cuboid) {
4225  Float::replace_if_smaller(min.x, cuboid.min.x);
4226  Float::replace_if_smaller(min.y, cuboid.min.y);
4227  Float::replace_if_smaller(min.z, cuboid.min.z);
4228  Float::replace_if_larger(max.x, cuboid.max.x);
4229  Float::replace_if_larger(max.y, cuboid.max.y);
4230  Float::replace_if_larger(max.z, cuboid.max.z);
4231  return *this;
4232  }
4233 
4239  HPS_INLINE Cuboid_3D & Expand(F border) {
4240  Vector_3D<F> delta (border, border, border);
4241  min -= delta;
4242  max += delta;
4243  return *this;
4244  }
4245 
4251  HPS_INLINE Cuboid_3D & Contract(F border) {
4252  Vector_3D<F> delta (border, border, border);
4253  min += delta;
4254  max -= delta;
4255  return *this;
4256  }
4257 
4258 private:
4259  void merge2(Point_3D<F> const & p1, Point_3D<F> const & p2) {
4260  if (p1.x > p2.x) {
4261  Float::replace_if_smaller(min.x, p2.x);
4262  Float::replace_if_larger(max.x, p1.x);
4263  }
4264  else {
4265  Float::replace_if_smaller(min.x, p1.x);
4266  Float::replace_if_larger(max.x, p2.x);
4267  }
4268 
4269  if (p1.y > p2.y) {
4270  Float::replace_if_smaller(min.y, p2.y);
4271  Float::replace_if_larger(max.y, p1.y);
4272  }
4273  else {
4274  Float::replace_if_smaller(min.y, p1.y);
4275  Float::replace_if_larger(max.y, p2.y);
4276  }
4277 
4278  if (p1.z > p2.z) {
4279  Float::replace_if_smaller(min.z, p2.z);
4280  Float::replace_if_larger(max.z, p1.z);
4281  }
4282  else {
4283  Float::replace_if_smaller(min.z, p1.z);
4284  Float::replace_if_larger(max.z, p2.z);
4285  }
4286  }
4287 
4288  HPS_INLINE static Point_3D<F> Limit_Point () {
4289  F const x = std::numeric_limits<F>::max();
4290  return Point_3D<F> (x, x, x);
4291  }
4292 
4293  bool LineIntersecting (Point_3D<F> const & start, Vector_3D<F> const & direction, bool is_ray) const;
4294 };
4295 
4296 typedef Cuboid_3D<float> SimpleCuboid;
4297 typedef Cuboid_3D<double> DSimpleCuboid;
4298 
4299 
4300 template <typename F>
4301 HPS_INLINE Cuboid_3D<F> Intersect(Cuboid_3D<F> const & a, Cuboid_3D<F> const & b) {
4302  Cuboid_3D<F> temp = a;
4303  return temp.Intersect(b);
4304 }
4305 
4306 template <typename F>
4307 HPS_INLINE Cuboid_3D<F> Union(Cuboid_3D<F> const & a, Cuboid_3D<F> const & b) {
4308  Cuboid_3D<F> temp = a;
4309  return temp.Union(b);
4310 }
4311 
4312 template <typename F>
4313 HPS_INLINE Cuboid_3D<F> Expand(Cuboid_3D<F> const & a, F border) {
4314  Cuboid_3D<F> temp = a;
4315  return temp.Expand(border);
4316 }
4317 
4318 template <typename F>
4319 HPS_INLINE Cuboid_3D<F> Contract(Cuboid_3D<F> const & a, F border) {
4320  Cuboid_3D<F> temp = a;
4321  return temp.Contract(border);
4322 }
4323 
4324 
4325 
4326 template <typename F>
4327 struct HPS_TEMPLATE_API Sphere_3D {
4328  Point_3D<F> center;
4329  F radius;
4330 
4331  Sphere_3D () : center(Point_3D<F>(0, 0, 0)), radius(-1) {}
4332 
4333  template <typename D>
4334  explicit Sphere_3D (Sphere_3D<D> const & that) : center(Point_3D<F>(that.center)), radius(F(that.radius)) {}
4335 
4336  Sphere_3D (Cuboid_3D<F> const & cuboid) {
4337  if (cuboid.max.x < cuboid.min.x || cuboid.max.y < cuboid.min.y || cuboid.max.z < cuboid.min.z)
4338  *this = Invalid();
4339  else {
4340  center = Midpoint(cuboid.min, cuboid.max);
4341  radius = F(0.5 * cuboid.Diagonal().Length());
4342  }
4343  }
4344 
4345  Sphere_3D (Point_3D<F> const & starting_center, F in_radius = 0) : center(starting_center), radius(in_radius) {}
4346 
4347  Sphere_3D (size_t count, Point_3D<F> const * points) : radius(0.0f) {
4348  Cuboid_3D<F> cuboid(count, points);
4349  center = Midpoint(cuboid.min, cuboid.max);
4350  Engulf (count, points);
4351  }
4352 
4353  template <typename T>
4354  Sphere_3D (size_t count, T const * indices, Point_3D<F> const * points) : radius(0.0f) {
4355  Cuboid_3D<F> cuboid(count, indices, points);
4356  center = Midpoint(cuboid.min, cuboid.max);
4357  Engulf (count, indices, points);
4358  }
4359 
4360  Sphere_3D (size_t count, Point_3D<F> const * points, Point_3D<F> const & starting_center)
4361  : center(starting_center), radius(0) {
4362  Engulf (count, points);
4363  }
4364 
4365  template <typename T>
4366  Sphere_3D (size_t count, T const * indices, Point_3D<F> const * points, Point_3D<F> const & starting_center)
4367  : center(starting_center), radius(0) {
4368  Engulf (count, indices, points);
4369  }
4370 
4371  HPS_INLINE bool IsValid() const {
4372  return radius >= 0;
4373  }
4374 
4375  static HPS_INLINE Sphere_3D Invalid() {return Sphere_3D(Point_3D<F>(0,0,0), -1);};
4376 
4377  void Invalidate() {radius = -1;}
4378 
4379  HPS_INLINE bool operator== (Sphere_3D const & sphere) const { return (center == sphere.center && radius == sphere.radius); }
4380  HPS_INLINE bool operator!= (Sphere_3D const & sphere) const { return !(*this == sphere); }
4381 
4382  HPS_INLINE F Volume () const { return F((4.0 / 3.0 * PI) * radius * radius * radius); }
4383 
4384  HPS_INLINE void Merge(Point_3D<F> const & point) {
4385  Vector_3D<F> dir = point - center;
4386  F distance = (F)dir.Length();
4387 
4388  if (distance > radius) {
4389  F t = F(0.5) * (distance - radius);
4390  center += t * dir.Normalize();
4391  radius += t;
4392  }
4393  }
4394 
4395  HPS_INLINE void Merge(size_t count, Point_3D<F> const * points) {
4396  F radius_squared = radius * radius;
4397  for (size_t i = 0; i < count; ++i) {
4398  Vector_3D<F> dir = *points - center;
4399  F distance_squared = (F)dir.LengthSquared();
4400 
4401  if (distance_squared > radius_squared) {
4402  F distance = sqrt(distance_squared);
4403  F t = F(0.5) * ( distance - radius);
4404  center += t * (distance > Float_Traits<F>::Epsilon() ? dir / distance : Vector_3D<F>::Zero());
4405  radius += t;
4406  radius_squared = radius * radius;
4407  }
4408 
4409  ++points;
4410  }
4411  }
4412 
4413  HPS_INLINE void Merge (Sphere_3D const & sphere) {
4414  Vector_3D<F> dir = sphere.center - center;
4415  F distance = (F)dir.Length();
4416 
4417  if (distance + sphere.radius > radius) {
4418  if (distance + radius > sphere.radius) {
4419  F t = F(0.5 * (sphere.radius + distance - radius));
4420  center += t * dir.Normalize();
4421  radius += t;
4422  }
4423  else {
4424  center = sphere.center;
4425  radius = sphere.radius;
4426  }
4427  }
4428  }
4429 
4430  HPS_INLINE void Merge (Cuboid_3D<F> const & cuboid) { Merge (Sphere_3D (cuboid)); }
4431 
4432 private:
4433  // Engulf expands the sphere to include the points, but does not change the center as Merge does
4434  HPS_INLINE void Engulf (size_t count, Point_3D<F> const * points) {
4435  double rsq = radius * radius;
4436  for (size_t i = 0; i < count; ++i) {
4437  double dsq = (*points++ - center).LengthSquared();
4438  if (dsq > rsq)
4439  rsq = dsq;
4440  }
4441  radius = (F)sqrt(rsq);
4442  }
4443 
4444  template <typename T>
4445  HPS_INLINE void Engulf (size_t count, T const * indices, Point_3D<F> const * points) {
4446  double rsq = radius * radius;
4447  for (size_t i = 0; i < count; ++i) {
4448  double dsq = (points[*indices++] - center).LengthSquared();
4449  if (dsq > rsq)
4450  rsq = dsq;
4451  }
4452  radius = (F)sqrt(rsq);
4453  }
4454 };
4455 
4456 typedef Sphere_3D<float> SimpleSphere;
4457 typedef Sphere_3D<double> DSimpleSphere;
4458 
4459 
4460 template <typename F>
4461 HPS_INLINE Cuboid_3D<F>::Cuboid_3D(Sphere_3D<F> const & sphere) {
4462  if (sphere.radius < 0)
4463  *this = Invalid();
4464  else {
4465  min = Point_3D<F>(sphere.center.x - sphere.radius, sphere.center.y - sphere.radius, sphere.center.z - sphere.radius);
4466  max = Point_3D<F>(sphere.center.x + sphere.radius, sphere.center.y + sphere.radius, sphere.center.z + sphere.radius);
4467  }
4468 }
4469 
4470 
4471 
4472 
4473 class RGB24Color;
4474 class RGBA32Color;
4475 class RGBAS32Color;
4476 class RGBAColor;
4477 
4478 class HPS_API RGBColor {
4479 public:
4480  float red;
4481  float green;
4482  float blue;
4483 
4484  HPS_INLINE RGBColor () {}
4485  HPS_INLINE RGBColor (float r, float g, float b) : red (r), green (g), blue (b) {}
4486  explicit HPS_INLINE RGBColor (RGB24Color const & c24);
4487  explicit HPS_INLINE RGBColor (float gray) : red (gray), green (gray), blue (gray) {}
4488  explicit HPS_INLINE RGBColor (RGBAS32Color const & c32);
4489  explicit HPS_INLINE RGBColor (RGBA32Color const & c32);
4490  explicit HPS_INLINE RGBColor (RGBAColor const & c);
4491 
4492  HPS_INLINE bool IsGray() const {return (red == green && green == blue);}
4493  HPS_INLINE float Gray() const { return 0.3125f * red + 0.5000f * green + 0.1875f * blue; }
4494  float Distance(RGBColor const & other_color) const;
4495  HPS_INLINE bool IsValid() const {
4496  return (Float::extract_sign_bit(red) | Float::extract_sign_bit(green) | Float::extract_sign_bit(blue)) == 0;
4497  }
4498 
4499  HPS_INLINE bool operator== (RGBColor const & c) const { return red == c.red && green == c.green && blue == c.blue; }
4500  HPS_INLINE bool operator!= (RGBColor const & c) const { return !(*this == c); }
4501 
4502  HPS_INLINE bool Equals(RGBColor const & c, int in_tolerance = 32) const
4503  { return Float::Equals(red, c.red, in_tolerance) && Float::Equals(green, c.green, in_tolerance) && Float::Equals(blue, c.blue, in_tolerance); }
4504 
4505  HPS_INLINE RGBColor & operator*= (RGBColor const & c) { red *= c.red; green *= c.green; blue *= c.blue; return *this; }
4506  HPS_INLINE RGBColor & operator+= (RGBColor const & c) { red += c.red; green += c.green; blue += c.blue; return *this; }
4507  HPS_INLINE RGBColor & operator-= (RGBColor const & c) { red -= c.red; green -= c.green; blue -= c.blue; return *this; }
4508  HPS_INLINE RGBColor const operator* (RGBColor const & c) const { return RGBColor (red * c.red, green * c.green, blue * c.blue); }
4509  HPS_INLINE RGBColor const operator+ (RGBColor const & c) const { return RGBColor (red + c.red, green + c.green, blue + c.blue); }
4510  HPS_INLINE RGBColor const operator- (RGBColor const & c) const { return RGBColor (red - c.red, green - c.green, blue - c.blue); }
4511 
4512  HPS_INLINE RGBColor & operator*= (float s) { red *= s; green *= s; blue *= s; return *this; }
4513  HPS_INLINE RGBColor & operator/= (float s) { return operator*= (1.0f / s); }
4514  HPS_INLINE RGBColor & operator+= (float s) { red += s; green += s; blue += s; return *this; }
4515  HPS_INLINE RGBColor & operator-= (float s) { red -= s; green -= s; blue -= s; return *this; }
4516  HPS_INLINE RGBColor const operator* (float s) const { return RGBColor (red * s, green * s, blue * s); }
4517  HPS_INLINE RGBColor const operator/ (float s) const { return operator* (1.0f / s); }
4518  HPS_INLINE RGBColor const operator+ (float s) const { return RGBColor (red + s, green + s, blue + s); }
4519  HPS_INLINE RGBColor const operator- (float s) const { return RGBColor (red - s, green - s, blue - s); }
4520 
4521  static HPS_INLINE RGBColor Black() {return RGBColor (0, 0, 0);};
4522  static HPS_INLINE RGBColor White() {return RGBColor (1, 1, 1);};
4523  static HPS_INLINE RGBColor Invalid() {return RGBColor (-1, -1, -1);};
4524 
4525  void ShowHLS(float & out_hue, float & out_lightness, float & out_saturation) const;
4526  void ShowHSV(float & out_hue, float & out_saturation, float & out_value) const;
4527  void ShowHIC(float & out_hue, float & out_intensity, float & out_chromaticity) const;
4528 
4529  static RGBColor HLS(float in_hue, float in_lightness, float in_saturation);
4530  static RGBColor HSV(float in_hue, float in_saturation, float in_value);
4531  static RGBColor HIC(float in_hue, float in_intensity, float in_chromaticity);
4532 };
4533 
4534 HPS_INLINE RGBColor const operator* (float s, RGBColor const & v) { return RGBColor (s * v.red, s * v.green, s * v.blue); }
4535 HPS_INLINE RGBColor const operator+ (float s, RGBColor const & v) { return RGBColor (s + v.red, s + v.green, s + v.blue); }
4536 HPS_INLINE RGBColor const operator- (float s, RGBColor const & v) { return RGBColor (s - v.red, s - v.green, s - v.blue); }
4537 
4538 
4539 class HPS_API RGBAColor {
4540 public:
4541 
4542  float red;
4543  float green;
4544  float blue;
4545  float alpha;
4547  HPS_INLINE RGBAColor () {}
4548  explicit HPS_INLINE RGBAColor (float gray, float a = 1) : red (gray), green (gray), blue (gray), alpha (a) {}
4549  HPS_INLINE RGBAColor (float r, float g, float b, float a = 1) : red (r), green (g), blue (b), alpha (a) {}
4550 
4551  HPS_INLINE RGBAColor (RGBColor const & c) {
4552  memcpy(this, &c, sizeof(RGBColor)); //-V512
4553  alpha = 1.0f;
4554  Float::apply_sign_bit(alpha, Float::extract_sign_bit(c.red) | Float::extract_sign_bit(c.green) | Float::extract_sign_bit(c.blue));
4555  }
4556  HPS_INLINE RGBAColor (RGBColor const & c, float a) {
4557  memcpy(this, &c, sizeof(RGBColor));
4558  memcpy(&alpha, &a, sizeof(float));
4559  Float::apply_sign_bit(alpha, Float::extract_sign_bit(c.red) | Float::extract_sign_bit(c.green) | Float::extract_sign_bit(c.blue));
4560  }
4561  explicit HPS_INLINE RGBAColor (RGBA32Color const & c32);
4562  explicit HPS_INLINE RGBAColor (RGBAS32Color const & c32);
4563 
4564  HPS_INLINE bool IsGray() const {return (red == green && green == blue);}
4565  HPS_INLINE float Gray() const { return 0.3125f * red + 0.5000f * green + 0.1875f * blue; }
4566  HPS_INLINE bool IsValid() const {
4567  return (Float::extract_sign_bit(red) | Float::extract_sign_bit(green) | Float::extract_sign_bit(blue) | Float::extract_sign_bit(alpha)) == 0;
4568  }
4569 
4576  HPS_INLINE bool operator== (RGBAColor const & c) const { return red == c.red && green == c.green && blue == c.blue && alpha == c.alpha; }
4577 
4584  HPS_INLINE bool operator!= (RGBAColor const & c) const { return !(*this == c); }
4585 
4586  HPS_INLINE bool Equals(RGBAColor const & c, int in_tolerance = 32) const {
4587  return Float::Equals(red, c.red, in_tolerance) && Float::Equals(green, c.green, in_tolerance) &&
4588  Float::Equals(blue, c.blue, in_tolerance) && Float::Equals(alpha, c.alpha, in_tolerance);
4589  }
4590 
4591  HPS_INLINE RGBAColor & operator*= (RGBAColor const & c) { red *= c.red; green *= c.green; blue *= c.blue; alpha *= c.alpha; return *this; }
4592  HPS_INLINE RGBAColor & operator+= (RGBAColor const & c) { red += c.red; green += c.green; blue += c.blue; alpha += c.alpha; return *this; }
4593  HPS_INLINE RGBAColor & operator-= (RGBAColor const & c) { red -= c.red; green -= c.green; blue -= c.blue; alpha -= c.alpha; return *this; }
4594  HPS_INLINE RGBAColor const operator* (RGBAColor const & c) const { return RGBAColor (red * c.red, green * c.green, blue * c.blue, alpha * c.alpha); }
4595  HPS_INLINE RGBAColor const operator+ (RGBAColor const & c) const { return RGBAColor (red + c.red, green + c.green, blue + c.blue, alpha + c.alpha); }
4596  HPS_INLINE RGBAColor const operator- (RGBAColor const & c) const { return RGBAColor (red - c.red, green - c.green, blue - c.blue, alpha - c.alpha); }
4597 
4598  HPS_INLINE RGBAColor & operator*= (float s) { red *= s; green *= s; blue *= s; alpha *= s; return *this; }
4599  HPS_INLINE RGBAColor & operator/= (float s) { return operator*= (1.0f / s); }
4600  HPS_INLINE RGBAColor & operator+= (float s) { red += s; green += s; blue += s; alpha += s; return *this; }
4601  HPS_INLINE RGBAColor & operator-= (float s) { red -= s; green -= s; blue -= s; alpha -= s; return *this; }
4602  HPS_INLINE RGBAColor const operator* (float s) const { return RGBAColor (red * s, green * s, blue * s, alpha * s); }
4603  HPS_INLINE RGBAColor const operator/ (float s) const { return operator* (1.0f / s); }
4604  HPS_INLINE RGBAColor const operator+ (float s) const { return RGBAColor (red + s, green + s, blue + s, alpha + s); }
4605  HPS_INLINE RGBAColor const operator- (float s) const { return RGBAColor (red - s, green - s, blue - s, alpha - s); }
4606 
4607  HPS_INLINE RGBAColor & operator*= (RGBColor const & c) { red *= c.red; green *= c.green; blue *= c.blue; return *this; }
4608  HPS_INLINE RGBAColor & operator+= (RGBColor const & c) { red += c.red; green += c.green; blue += c.blue; return *this; }
4609  HPS_INLINE RGBAColor & operator-= (RGBColor const & c) { red -= c.red; green -= c.green; blue -= c.blue; return *this; }
4610  HPS_INLINE RGBAColor const operator* (RGBColor const & c) const { return RGBAColor (red * c.red, green * c.green, blue * c.blue, alpha); }
4611  HPS_INLINE RGBAColor const operator+ (RGBColor const & c) const { return RGBAColor (red + c.red, green + c.green, blue + c.blue, alpha); }
4612  HPS_INLINE RGBAColor const operator- (RGBColor const & c) const { return RGBAColor (red - c.red, green - c.green, blue - c.blue, alpha); }
4613 
4614  static HPS_INLINE RGBAColor Black() {return RGBAColor (0, 0, 0, 1);};
4615  static HPS_INLINE RGBAColor White() {return RGBAColor (1, 1, 1, 1);};
4616  static HPS_INLINE RGBAColor Nothing() {return RGBAColor (0, 0, 0, 0);};
4617  static HPS_INLINE RGBAColor Invalid() {return RGBAColor (-1, -1, -1, -1);};
4618 };
4619 
4620 HPS_INLINE RGBAColor const operator* (float s, RGBAColor const & v) { return RGBAColor (s * v.red, s * v.green, s * v.blue, s * v.alpha); }
4621 HPS_INLINE RGBAColor const operator+ (float s, RGBAColor const & v) { return RGBAColor (s + v.red, s + v.green, s + v.blue, s + v.alpha); }
4622 HPS_INLINE RGBAColor const operator- (float s, RGBAColor const & v) { return RGBAColor (s - v.red, s - v.green, s - v.blue, s - v.alpha); }
4623 
4624 
4625 
4627 public:
4628  enum Order {
4629  Order_ABGR,
4630  Order_RGBA,
4631  Order_BGRA
4632  };
4633 
4634 #ifdef _MSC_VER
4635  HPS_INLINE static Order Preferred_Order () {return Order_BGRA;}
4636  unsigned char b, g, r, a;
4637 #endif
4638 
4639 #ifdef __linux__
4640  HPS_INLINE static Order Preferred_Order () {return Order_RGBA;}
4641  unsigned char r, g, b, a;
4642 #endif
4643 
4644 #ifdef __APPLE_CC__
4645  HPS_INLINE static Order Preferred_Order () {return Order_RGBA;}
4646  unsigned char r, g, b, a;
4647 #endif
4648 };
4649 
4650 
4651 
4653 public:
4654 
4655  HPS_INLINE RGBAS32Color () /* : DirectRGBColor() */ {}
4656  explicit HPS_INLINE RGBAS32Color (unsigned char gray, unsigned char aa = 255) {
4657  r = gray;
4658  g = gray;
4659  b = gray;
4660  a = aa;
4661  }
4662  HPS_INLINE RGBAS32Color (unsigned char rr, unsigned char gg, unsigned char bb, unsigned char aa = 255) {
4663  r = rr;
4664  g = gg;
4665  b = bb;
4666  a = aa;
4667  }
4668  HPS_INLINE RGBAS32Color (DirectRGBColor const & c) : DirectRGBColor(c) {};
4669 
4670  explicit HPS_INLINE RGBAS32Color (RGBColor const & c)
4671  {
4672  r = Float::unit_to_byte(c.red);
4673  g = Float::unit_to_byte(c.green);
4674  b = Float::unit_to_byte(c.blue);
4675  a = 255;
4676  }
4677 
4678  HPS_INLINE RGBAS32Color (RGB24Color const & c);
4679 
4680  HPS_INLINE RGBAS32Color (RGBA32Color const & c);
4681 
4682  HPS_INLINE RGBAS32Color (RGBColor const & c, float alpha)
4683  {
4684  r = Float::unit_to_byte(c.red);
4685  g = Float::unit_to_byte(c.green);
4686  b = Float::unit_to_byte(c.blue);
4687  a = Float::unit_to_byte(alpha);
4688  }
4689  HPS_INLINE RGBAS32Color (RGBColor const & c, unsigned char aa)
4690  {
4691  r = Float::unit_to_byte(c.red);
4692  g = Float::unit_to_byte(c.green);
4693  b = Float::unit_to_byte(c.blue);
4694  a = aa;
4695  }
4696  explicit HPS_INLINE RGBAS32Color (RGBAColor const & c)
4697  {
4698  r = Float::unit_to_byte(c.red);
4699  g = Float::unit_to_byte(c.green);
4700  b = Float::unit_to_byte(c.blue);
4701  a = Float::unit_to_byte(c.alpha);
4702  }
4703  HPS_INLINE RGBAS32Color (RGBAColor const & c, unsigned char mix)
4704  {
4705  r = Float::unit_to_byte(c.red);
4706  g = Float::unit_to_byte(c.green);
4707  b = Float::unit_to_byte(c.blue);
4708  a = Float::unit_to_byte_scaled(c.alpha, mix);
4709  }
4710 
4711  HPS_INLINE bool IsGray() const {return (r == g && g == b);}
4712  HPS_INLINE unsigned char Gray() const { return (unsigned char)(0.3125f * (float)r + 0.5000f * (float)g + 0.1875f * (float)b); }
4713  HPS_INLINE bool IsValid() const { return ((r | g | b | a) != 0); }
4714 
4715  HPS_INLINE bool operator== (RGBAS32Color const & c) const { return (r == c.r && g == c.g && b == c.b && a == c.a); }
4716  HPS_INLINE bool operator!= (RGBAS32Color const & c) const { return !(*this == c); }
4717 
4718  static HPS_INLINE RGBAS32Color Black() {return RGBAS32Color (0, 0, 0, 255);};
4719  static HPS_INLINE RGBAS32Color White() {return RGBAS32Color (255, 255, 255, 255);};
4720  static HPS_INLINE RGBAS32Color Invalid() {return RGBAS32Color (0, 0, 0, 0);};
4721 
4722  static HPS_INLINE unsigned char Opaque_Alpha () {return 0xFF;}
4723 };
4724 
4726 public:
4727  unsigned char r;
4728  unsigned char g;
4729  unsigned char b;
4730  unsigned char a;
4731 
4732  HPS_INLINE RGBA32Color () {}
4733  explicit HPS_INLINE RGBA32Color (unsigned char gray, unsigned char aa = 255)
4734  : r (gray), g (gray), b (gray), a (aa) {}
4735  HPS_INLINE RGBA32Color (unsigned char rr, unsigned char gg, unsigned char bb, unsigned char aa = 255)
4736  : r (rr), g (gg), b (bb), a (aa) {}
4737  HPS_INLINE RGBA32Color (RGBAS32Color const & c32)
4738  : r (c32.r), g (c32.g), b (c32.b), a (c32.a) {}
4739  explicit HPS_INLINE RGBA32Color (RGBColor const & c) {
4740  r = Float::unit_to_byte(c.red);
4741  g = Float::unit_to_byte(c.green);
4742  b = Float::unit_to_byte(c.blue);
4743  a = 255;
4744  }
4745  HPS_INLINE RGBA32Color (RGBColor const & c, float alpha) {
4746  r = Float::unit_to_byte(c.red);
4747  g = Float::unit_to_byte(c.green);
4748  b = Float::unit_to_byte(c.blue);
4749  a = Float::unit_to_byte(alpha);
4750  }
4751  HPS_INLINE RGBA32Color (RGBColor const & c, unsigned char aa) {
4752  r = Float::unit_to_byte(c.red);
4753  g = Float::unit_to_byte(c.green);
4754  b = Float::unit_to_byte(c.blue);
4755  a = aa;
4756  }
4757  explicit HPS_INLINE RGBA32Color (RGBAColor const & c) {
4758  r = Float::unit_to_byte(c.red);
4759  g = Float::unit_to_byte(c.green);
4760  b = Float::unit_to_byte(c.blue);
4761  a = Float::unit_to_byte(c.alpha);
4762  }
4763  HPS_INLINE RGBA32Color (RGBAColor const & c, unsigned char mix) {
4764  r = Float::unit_to_byte(c.red);
4765  g = Float::unit_to_byte(c.green);
4766  b = Float::unit_to_byte(c.blue);
4767  a = Float::unit_to_byte_scaled(c.alpha, mix);
4768  }
4769 
4770  HPS_INLINE bool IsGray() const {return (r == g && g == b);}
4771  HPS_INLINE unsigned char Gray() const { return (unsigned char)(0.3125f * (float)r + 0.5000f * (float)g + 0.1875f * (float)b); }
4772 
4773  HPS_INLINE bool operator== (RGBA32Color const & c) const { return (r == c.r && g == c.g && b == c.b && a == c.a); }
4774  HPS_INLINE bool operator!= (RGBA32Color const & c) const { return !(*this == c); }
4775 
4776  static HPS_INLINE RGBA32Color Black() {return RGBA32Color (0, 0, 0, 255);};
4777  static HPS_INLINE RGBA32Color White() {return RGBA32Color (255, 255, 255, 255);};
4778 
4779  static HPS_INLINE unsigned char Opaque_Alpha () {return 0xFF;}
4780 };
4781 
4782 
4784 {
4785 public:
4786  unsigned char r;
4787  unsigned char g;
4788  unsigned char b;
4789 
4790  HPS_INLINE RGB24Color () {}
4791  explicit HPS_INLINE RGB24Color (unsigned char gray)
4792  : r (gray), g (gray), b (gray) {}
4793  HPS_INLINE RGB24Color (unsigned char rr, unsigned char gg, unsigned char bb)
4794  : r (rr), g (gg), b (bb) {}
4795  explicit HPS_INLINE RGB24Color (RGBColor const & c) {
4796  r = Float::unit_to_byte(c.red);
4797  g = Float::unit_to_byte(c.green);
4798  b = Float::unit_to_byte(c.blue);
4799  }
4800 
4801  HPS_INLINE bool IsGray() const {return (r == g && g == b);}
4802  HPS_INLINE unsigned char Gray() const { return (unsigned char)(0.3125f * (float)r + 0.5000f * (float)g + 0.1875f * (float)b); }
4803 
4804  HPS_INLINE bool operator== (RGB24Color const & c) const { return (r == c.r && g == c.g && b == c.b); }
4805  HPS_INLINE bool operator!= (RGB24Color const & c) const { return !(*this == c); }
4806 };
4807 
4808 HPS_INLINE RGBColor::RGBColor (RGBAS32Color const & c32) {
4809  red = Float::C2F(c32.r);
4810  green = Float::C2F(c32.g);
4811  blue = Float::C2F(c32.b);
4812 }
4813 
4814 HPS_INLINE RGBColor::RGBColor (RGBA32Color const & c32) {
4815  red = Float::C2F(c32.r);
4816  green = Float::C2F(c32.g);
4817  blue = Float::C2F(c32.b);
4818 }
4819 
4820 HPS_INLINE RGBColor::RGBColor (RGBAColor const & c) {
4821  red = c.red;
4822  green = c.green;
4823  blue = c.blue;
4824 }
4825 
4826 HPS_INLINE RGBColor::RGBColor (RGB24Color const & c24) {
4827  red = Float::C2F(c24.r);
4828  green = Float::C2F(c24.g);
4829  blue = Float::C2F(c24.b);
4830 }
4831 
4832 HPS_INLINE RGBAS32Color::RGBAS32Color (RGB24Color const & c)
4833 {
4834  r = c.r;
4835  g = c.g;
4836  b = c.b;
4837  a = 255;
4838 }
4839 
4840 HPS_INLINE RGBAS32Color::RGBAS32Color (RGBA32Color const & c)
4841 {
4842  r = c.r;
4843  g = c.g;
4844  b = c.b;
4845  a = c.a;
4846 }
4847 
4848 HPS_INLINE RGBAColor::RGBAColor (RGBAS32Color const & c32) {
4849  red = Float::C2F(c32.r);
4850  green = Float::C2F(c32.g);
4851  blue = Float::C2F(c32.b);
4852  alpha = Float::C2F(c32.a);
4853 }
4854 
4855 HPS_INLINE RGBAColor::RGBAColor (RGBA32Color const & c32) {
4856  red = Float::C2F(c32.r);
4857  green = Float::C2F(c32.g);
4858  blue = Float::C2F(c32.b);
4859  alpha = Float::C2F(c32.a);
4860 }
4861 
4862 HPS_INLINE RGBColor Modulate(RGBColor const & a, RGBColor const & b) {
4863  return RGBColor(a.red * b.red, a.green * b.green, a.blue * b.blue);
4864 }
4865 
4866 
4867 
4868 HPS_INLINE RGBColor Interpolate(RGBColor const & a, RGBColor const & b, float t) {
4869  return RGBColor(a.red + (b.red - a.red) * t, a.green + (b.green - a.green) * t, a.blue + (b.blue - a.blue) * t);
4870 }
4871 
4872 HPS_INLINE RGBAColor Interpolate(RGBAColor const & a, RGBAColor const & b, float t) {
4873  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);
4874 }
4875 
4876 HPS_INLINE RGBAS32Color Interpolate(RGBAS32Color const & a, RGBAS32Color const & b, float t) {
4877  return RGBAS32Color(
4878  (unsigned char)(a.r + ((float)b.r - (float)a.r) * t),
4879  (unsigned char)(a.g + ((float)b.g - (float)a.g) * t),
4880  (unsigned char)(a.b + ((float)b.b - (float)a.b) * t),
4881  (unsigned char)(a.a + ((float)b.a - (float)a.a) * t));
4882 }
4883 
4884 HPS_INLINE RGBA32Color Interpolate(RGBA32Color const & a, RGBA32Color const & b, float t) {
4885  return RGBA32Color(
4886  (unsigned char)(a.r + ((float)b.r - (float)a.r) * t),
4887  (unsigned char)(a.g + ((float)b.g - (float)a.g) * t),
4888  (unsigned char)(a.b + ((float)b.b - (float)a.b) * t),
4889  (unsigned char)(a.a + ((float)b.a - (float)a.a) * t));
4890 }
4891 
4892 HPS_INLINE RGB24Color Interpolate(RGB24Color const & a, RGB24Color const & b, float t) {
4893  return RGB24Color(
4894  (unsigned char)(a.r + ((float)b.r - (float)a.r) * t),
4895  (unsigned char)(a.g + ((float)b.g - (float)a.g) * t),
4896  (unsigned char)(a.b + ((float)b.b - (float)a.b) * t));
4897 }
4898 
4899 
4900 
4901 class HPS_API Quaternion {
4902 public:
4903  float w;
4904  float x;
4905  float y;
4906  float z;
4907 
4908  Quaternion() : w(0.0f), x(0.0f), y(0.0f), z(0.0f) { }
4909 
4910  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) { }
4911 
4912  Quaternion(Quaternion const & that) : w(that.w), x(that.x), y(that.y), z(that.z) { }
4913 
4914  Quaternion const & Normalize() {
4915  float mag = Norm();
4916 
4917  if (mag > 0) {
4918  w /= mag;
4919  x /= mag;
4920  y /= mag;
4921  z /= mag;
4922  }
4923  return *this;
4924  }
4925 
4926 
4927  Quaternion operator* (Quaternion const & in_right) const {
4928  return Quaternion(w*in_right.w - x*in_right.x - y*in_right.y - z*in_right.z,
4929  y*in_right.z - z*in_right.y + w*in_right.x + x*in_right.w,
4930  z*in_right.x - x*in_right.z + w*in_right.y + y*in_right.w,
4931  x*in_right.y - y*in_right.x + w*in_right.z + z*in_right.w);
4932  }
4933 
4934  Quaternion operator* (float in_right) const {
4935  return Quaternion(w*in_right, x*in_right, y*in_right, z*in_right);
4936  }
4937 
4938  friend Quaternion operator* (float in_left, Quaternion const & in_right) {
4939  return Quaternion(in_left*in_right.w, in_left*in_right.x, in_left*in_right.y, in_left*in_right.z);
4940  }
4941 
4942  Quaternion operator/ (float in_right) const {
4943  return Quaternion(w/in_right, x/in_right, y/in_right, z/in_right);
4944  }
4945 
4946  Quaternion operator- (Quaternion const & in_right) const {
4947  return Quaternion(w-in_right.w, x-in_right.x, y-in_right.y, z-in_right.z);
4948  }
4949 
4950  Quaternion operator+ (Quaternion const & in_right) const {
4951  return Quaternion(w+in_right.w, x+in_right.x, y+in_right.y, z+in_right.z);
4952  }
4953 
4954  inline float Norm() const {
4955  return static_cast<float>(sqrt(w*w + x*x + y*y + z*z));
4956  }
4957 
4958 
4959  Quaternion Log() const {
4960  Quaternion ret;
4961  float mag_q = Norm();
4962  float mag_V = static_cast<float>(sqrt(x*x + y*y + z*z));
4963 
4964  ret.w = static_cast<float>(log(mag_q));
4965 
4966  if (mag_V > 0) {
4967  float scale = static_cast<float>(acos(w / mag_q) / mag_V);
4968 
4969  ret.x = x * scale;
4970  ret.y = y * scale;
4971  ret.z = z * scale;
4972  }
4973  else
4974  ret.x = ret.y = ret.z = 0;
4975 
4976  return ret;
4977  }
4978 
4979  Quaternion Exp() const {
4980  Quaternion ret;
4981  float ea = static_cast<float>(exp(w));
4982  float mag_V = static_cast<float>(sqrt(x*x + y*y + z*z));
4983  float scale = ea * sin(mag_V) / mag_V;
4984 
4985  ret.w = ea * cos(mag_V);
4986  ret.x = scale * x;
4987  ret.y = scale * y;
4988  ret.z = scale * z;
4989 
4990  return ret;
4991  }
4992 
4993  Quaternion Lerp(Quaternion const & in_right, float in_fraction) const {
4994  Quaternion ret = *this + in_fraction * (in_right - *this);
4995  return ret.Normalize();
4996  }
4997 
4998 
4999  Quaternion Slerp(Quaternion const & in_right, float in_fraction, bool in_shortest_path_only = true) const {
5000  Quaternion q3;
5001  float dot = x*in_right.x + y*in_right.y + z*in_right.z + w*in_right.w;
5002 
5003  if (in_shortest_path_only && dot < 0) {
5004  dot = -dot;
5005  q3 = -1 * in_right;
5006  }
5007  else
5008  q3 = in_right;
5009 
5010  if (dot > -0.95f && dot < 0.95f) {
5011  float angle = static_cast<float>(acos(dot));
5012  float sina = static_cast<float>(sin(angle));
5013  float sinat = static_cast<float>(sin(angle*in_fraction));
5014  float sinaomt = static_cast<float>(sin(angle*(1-in_fraction)));
5015 
5016  return (*this * sinaomt + q3 * sinat) / sina;
5017  }
5018  else //if the angle is small, we use linear interpolation
5019  return Lerp(q3, in_fraction);
5020  }
5021 
5022 
5023  /*
5024  Spherical cubic interpolation between two Quaternions
5025  \param in_right The Quaternion for interpolation.
5026  \param in_control1 The first control point.
5027  \param in_control2 The second control point.
5028  \param in_fraction Interpolation distance (0 - 1).
5029  \return Result of interpolation.
5030  */
5031  Quaternion Squad(Quaternion const & in_right, Quaternion const & in_control1, Quaternion const & in_control2, float in_fraction) const {
5032  Quaternion q1 = Slerp(in_right , in_fraction, false);
5033  Quaternion q2 = in_control1.Slerp(in_control2, in_fraction, false);
5034 
5035  return q1.Slerp(q2, 2*in_fraction*(1-in_fraction), false);
5036  }
5037 
5044  Quaternion Spline(Quaternion const & in_previous, Quaternion const & in_next) const {
5045  Quaternion qni(w, -x, -y, -z);
5046 
5047  return *this * Quaternion(((qni*in_previous).Log() + (qni*in_next).Log()) / -4).Exp();
5048  }
5049 
5050 };
5051 
5053 {
5056  size_t dot_dc_count;
5057  size_t dot_3d_count;
5058  size_t line_dc_count;
5059  size_t line_3d_count;
5072  size_t raster_count;
5073  size_t segment_count;
5085 };
5086 
5087 typedef unsigned char byte;
5088 typedef signed char sbyte;
5089 typedef intptr_t WindowHandle;
5090 typedef int64_t TouchID;
5091 typedef intptr_t PlatformData;
5092 typedef intptr_t OpaqueHandle;
5093 
5094 /*
5095 HPS Lexicon:
5096 
5097 Concept Class -- A class that contains only enums and possibly static functions. The
5098  constructor is usually private because they are not intended to be instantiated.
5099 
5100 Database -- (1) The internal space that stores and manages all HOOPS objects. Access to
5101  database objects is subject to locking to prevent threading deadlocks. (2) The class
5102  of the same name, offering static functions to initiate operations that take place
5103  within the database.
5104 
5105 Key -- A reference counted smart pointer to an object in the database. The
5106 
5107 Kit -- A user space object that carries a complete specification for a geometry, attribute,
5108  option group, or other type. Modifying a kit has no effect on the database unless
5109  and until it is applied. Kits should generally be passed by reference because they
5110  are potentially very large and copying them can be arduous.
5111 
5112 Smart Pointer -- An encapsulated, reference counted pointer to an internal object. Smart
5113  pointers should generally be passed by value to ensure the reference count is
5114  correct.
5115 
5116 User Space -- The external space occupied by all user code. User space objects are not
5117  in the database and are not subject to locking.
5118 
5119 */
5120 
5124 class SegmentKey;
5125 class AttributesControl;
5126 class LineKit;
5127 class LineKey;
5128 class TextKey;
5129 class TextKit;
5130 class Key;
5131 class VisibilityControl;
5132 class CameraControl;
5133 class SelectabilityControl;
5134 class TransparencyKit;
5135 class TransparencyControl;
5136 class CullingKit;
5137 class CullingControl;
5138 class GlyphKit;
5139 class ShapeKit;
5141 class GlyphDefinition;
5142 class ShapeDefinition;
5143 class GeometryInsertControl;
5144 class GlyphElement;
5145 class ShapeElement;
5146 class TextAttributeControl;
5147 class TextAttributeKit;
5148 class LineAttributeKit;
5149 class LineAttributeControl;
5150 class EdgeAttributeKit;
5151 class EdgeAttributeControl;
5152 class CurveAttributeKit;
5153 class CurveAttributeControl;
5154 class GlyphPoint;
5155 class MatrixKit;
5157 class TextureMatrixControl;
5158 class TextureDefinition;
5159 class MaterialMappingKit;
5160 class PBRMaterialKit;
5162 class MaterialKit;
5163 class MarkerKit;
5164 class MarkerKey;
5165 class DistantLightKit;
5166 class DistantLightKey;
5167 class CuttingSectionKit;
5168 class CuttingSectionKey;
5171 class CylinderAttributeKit;
5173 class Cylinder;
5174 class CylinderKey;
5175 class CylinderKit;
5176 class SphereKey;
5177 class SphereKit;
5178 class SphereAttributeKit;
5180 class PolygonKit;
5181 class PolygonKey;
5182 class CircleKey;
5183 class CircleKit;
5184 class CircularArcKey;
5185 class CircularArcKit;
5186 class CircularWedgeKey;
5187 class CircularWedgeKit;
5188 class IncludeKey;
5189 class InfiniteLineKey;
5190 class InfiniteLineKit;
5191 class SpotlightKey;
5192 class SpotlightKit;
5193 class NURBSCurveKey;
5194 class NURBSCurveKit;
5195 class NURBSSurfaceKey;
5196 class NURBSSurfaceKit;
5197 class TrimKit;
5198 class TrimElement;
5199 class EllipseKey;
5200 class EllipseKit;
5201 class EllipticalArcKey;
5202 class EllipticalArcKit;
5203 class ShellKit;
5204 class ShellKey;
5205 class Shell;
5206 class MeshKit;
5207 class MeshKey;
5208 class WindowKey;
5209 class Database;
5212 class Driver;
5213 class Search;
5214 class PerformanceKit;
5215 class PerformanceControl;
5218 class DrawingAttributeKit;
5220 class PortfolioKey;
5221 class Selection;
5222 class SelectionOptionsKit;
5223 class SelectionResults;
5224 class SelectionItem;
5225 class SelectionControl;
5226 class HighlightControl;
5227 class HighlightOptionsKit;
5228 class ImageDefinition;
5229 class ImageKit;
5230 class TextureDefinition;
5231 class TextureOptionsKit;
5232 class NamedStyleDefinition;
5234 class GlyphDefinition;
5235 class LinePatternOptionsKit;
5236 class LinePatternDefinition;
5237 class LinePatternKit;
5238 class LinePatternElement;
5240 class CubeMapDefinition;
5241 class ShaderKit;
5242 class ShaderDefinition;
5243 class EmergencyHandler;
5244 class EventDispatcher;
5245 class EventHandler;
5246 class Event;
5247 class StandAloneWindowKey;
5249 class ApplicationWindowKey;
5251 class OffScreenWindowKey;
5254 class VisualEffectsControl;
5257 class ObjectPoint;
5258 class WorldPoint;
5259 class CameraPoint;
5260 class InnerWindowPoint;
5261 class InnerPixelPoint;
5262 class WindowPoint;
5263 class PixelPoint;
5264 class VisibilityKit;
5265 class CameraKit;
5266 class SelectabilityKit;
5267 class MarkerAttributeKit;
5268 class LightingAttributeKit;
5269 class VisualEffectsKit;
5270 class PostProcessEffectsKit;
5271 class Portfolio;
5272 class SubwindowControl;
5273 class SubwindowKit;
5274 class World;
5275 class DebuggingControl;
5276 class DebuggingKit;
5277 class KeyPath;
5278 class ContourLineKit;
5279 class ContourLineControl;
5280 class UTF8;
5281 class StyleControl;
5282 class PortfolioControl;
5283 class ConditionalExpression;
5284 class ConditionControl;
5285 class WindowInfoKit;
5286 class WindowInfoControl;
5287 class FontInfoState;
5288 class FontInfoControl;
5289 class SearchOptionsKit;
5290 class AttributeLockControl;
5291 class AttributeLockKit;
5292 class ReferenceKey;
5293 class StyleKey;
5294 class BoundingKit;
5295 class BoundingControl;
5296 class TransformMaskKit;
5297 class TransformMaskControl;
5298 class ColorInterpolationKit;
5300 class UpdateOptionsKit;
5301 class UpdateOptionsControl;
5302 class GeometryKey;
5303 class TreeContext;
5306 class GridKit;
5307 class GridKey;
5311 class HighlightState;
5316 
5320 
5321 
5324 class HPS_API GlyphPoint
5325 {
5326 public:
5327 
5329  GlyphPoint();
5330 
5335  GlyphPoint(sbyte in_x, sbyte in_y);
5336 
5341  bool Equals(GlyphPoint const & in_that) const { return (x==in_that.x && y==in_that.y); }
5342 
5347  bool operator==(GlyphPoint const & in_that) const { return Equals(in_that); }
5348 
5353  bool operator!=(GlyphPoint const & in_that) const { return !Equals(in_that); }
5354 
5355  sbyte x;
5356  sbyte y;
5357 };
5358 
5361 enum class Type : uint32_t
5362 {
5363  None = 0x00000000,
5364  GenericMask = 0xffffff00,
5365 
5366  World = 0x00000001,
5367  UTF8 = 0x00000002,
5368  EventDispatcher = 0x00000003,
5369  EventHandler = 0x00000004,
5370  EventNotifier = 0x00000005,
5371  UpdateNotifier = 0x00000006,
5372  SearchResults = 0x00000008,
5373  FontSearchResults = 0x00000009,
5374  SelectionResults = 0x0000000a,
5375  SelectionItem = 0x0000000b,
5376  TreeContext = 0x0000000c,
5377  StreamToolkit = 0x0000000d,
5378  DriverEventHandler = 0x0000000e,
5379  HighlightSearchResults = 0x0000000f,
5380  OptimizeMappingResults = 0x00000010,
5381 
5382  IONotifier = 0x04000100,
5383  StreamImportNotifier = 0x04000101,
5384  STLImportNotifier = 0x04000102,
5385  OBJImportNotifier = 0x04000103,
5386  ExchangeImportNotifier = 0x04000104,
5387  SketchupImportNotifier = 0x04000105,
5388  ParasolidImportNotifier = 0x04000106,
5389  ExchangeTranslationNotifier = 0x04000107,
5390  ExchangeExportNotifier = 0x04000108,
5391  StreamExportNotifier = 0x04000109,
5392  ExchangeReloadNotifier = 0x0400010a,
5393  DWGImportNotifier = 0x0400010b,
5394  ExchangeParasolidImportNotifier = 0x0400010c,
5395  PointCloudImportNotifier = 0x0400010d,
5396  OOCImportNotifier = 0x0400010e,
5397  OBJExportNotifier = 0x0400010f,
5398 
5399  SearchResultsIterator = 0x01000001,
5400  FontSearchResultsIterator = 0x01000002,
5401  SelectionResultsIterator = 0x01000003,
5402  HighlightSearchResultsIterator = 0x01000004,
5403  OptimizeMappingResultsIterator = 0x01000005,
5404 
5405  Kit = 0x01000000,
5406  MarkerKit = 0x01000010,
5407  SphereAttributeKit = 0x01000011,
5408  TextAttributeKit = 0x01000012,
5409  TransparencyKit = 0x01000013,
5410  VisibilityKit = 0x01000014,
5411  VisualEffectsKit = 0x01000015,
5412  CuttingSectionAttributeKit = 0x01000016,
5413  CircleKit = 0x01000017,
5414  CircularArcKit = 0x01000018,
5415  CircularWedgeKit = 0x01000019,
5416  CuttingSectionKit = 0x0100001a,
5417  CylinderKit = 0x0100001b,
5418  DistantLightKit = 0x0100001c,
5419  EllipseKit = 0x0100001d,
5420  EllipticalArcKit = 0x0100001e,
5421  InfiniteLineKit = 0x0100001f,
5422  LineKit = 0x01000020,
5423  NURBSCurveKit = 0x01000021,
5424  MeshKit = 0x01000022,
5425  NURBSSurfaceKit = 0x01000023,
5426  PolygonKit = 0x01000024,
5427  SphereKit = 0x01000025,
5428  SpotlightKit = 0x01000026,
5429  ShellKit = 0x01000027,
5430  TextKit = 0x01000028,
5431  MaterialKit = 0x01000029,
5432  TrimKit = 0x0100002a,
5433  TextureOptionsKit = 0x0100002c,
5434  LinePatternKit = 0x0100002d,
5435  GlyphKit = 0x0100002e,
5436  ImageKit = 0x0100002f,
5437  LinePatternOptionsKit = 0x01000030,
5438  CameraKit = 0x01000031,
5439  BoundingKit = 0x01000032,
5440  CullingKit = 0x01000033,
5441  CurveAttributeKit = 0x01000034,
5442  CylinderAttributeKit = 0x01000035,
5443  EdgeAttributeKit = 0x01000036,
5444  LightingAttributeKit = 0x01000037,
5445  LineAttributeKit = 0x01000038,
5446  MarkerAttributeKit = 0x01000039,
5447  MaterialMappingKit = 0x0100003a,
5448  //MatrixKit = 0x0100003b,
5449  NURBSSurfaceAttributeKit = 0x0100003c,
5450  PostProcessEffectsKit = 0x0100003d,
5451  SelectabilityKit = 0x0100003e,
5452  SelectionOptionsKit = 0x0100003f,
5453  StandAloneWindowOptionsKit = 0x01000040,
5454  OffScreenWindowOptionsKit = 0x01000041,
5455  ApplicationWindowOptionsKit = 0x01000042,
5456  HighlightOptionsKit = 0x01000043,
5457  LinePatternParallelKit = 0x01000044,
5458  SubwindowKit = 0x01000045,
5459  PerformanceKit = 0x01000046,
5460  HiddenLineAttributeKit = 0x01000047,
5461  DrawingAttributeKit = 0x01000048,
5462  ShaderKit = 0x01000049,
5463  DebuggingKit = 0x0100004a,
5464  ContourLineKit = 0x0100004b,
5465  StreamImportOptionsKit = 0x0100004c,
5466  StreamImportResultsKit = 0x0100004d,
5467  StreamExportOptionsKit = 0x0100004e,
5468  StreamExportResultsKit = 0x0100004f,
5469  WindowInfoKit = 0x01000050,
5470  ImageImportOptionsKit = 0x01000051,
5471  SearchOptionsKit = 0x01000052,
5472  ShaderImportOptionsKit = 0x01000053,
5473  HardcopyExportOptionsKit = 0x01000055, // These two use the same Impl, so
5474  HardcopyGDIExportOptionsKit = 0x01001055, // we make sure their bits are compatible here
5475  AttributeLockKit = 0x01000056,
5476  TransformMaskKit = 0x01000057,
5477  ColorInterpolationKit = 0x01000058,
5478  UpdateOptionsKit = 0x01000059,
5479  ImageExportOptionsKit = 0x0100005a,
5480  OBJImportOptionsKit = 0x0100005b,
5481  OBJImportResultsKit = 0x0100005c,
5482  STLImportOptionsKit = 0x0100005d,
5483  STLImportResultsKit = 0x0100005e,
5484  ShellOptimizationOptionsKit = 0x0100005f,
5485  ShellRelationOptionsKit = 0x01000060,
5486  ShellRelationResultsKit = 0x01000061,
5487  GridKit = 0x01000062,
5488  CutGeometryGatheringOptionsKit = 0x01000063,
5489  SegmentOptimizationOptionsKit = 0x01000064,
5490  PointCloudImportOptionsKit = 0x01000065,
5491  PointCloudImportResultsKit = 0x01000066,
5492  ShapeKit = 0x01000067,
5493  HighlightSearchOptionsKit = 0x01000068,
5494  PBRMaterialKit = 0x01000069,
5495 
5496  LinePatternElement = 0x03000000,
5497  SolidLinePatternElement = 0x03000001,
5498  BlankLinePatternElement = 0x03000002,
5499  GlyphLinePatternElement = 0x03000003,
5500 
5501  GlyphElement = 0x05000000,
5502  DotGlyphElement = 0x05000001,
5503  LineGlyphElement = 0x05000002,
5504  EllipseGlyphElement = 0x05000003,
5505  CircularArcGlyphElement = 0x05000004,
5506  InfiniteLineGlyphElement = 0x05000005,
5507  SphereGlyphElement = 0x05000006,
5508  ImageGlyphElement = 0x05000007,
5509 
5510  TrimElement = 0x07000000,
5511 
5512  ConditionalExpression = 0x09000000,
5513  NOTCondition = 0x09000001,
5514  ANDCondition = 0x09000002,
5515  ORCondition = 0x09000003,
5516  XORCondition = 0x09000004,
5517  EQCondition = 0x09000005,
5518  NEQCondition = 0x09000006,
5519  GTCondition = 0x09000007,
5520  LTCondition = 0x09000008,
5521  GTEQCondition = 0x09000009,
5522  LTEQCondition = 0x0900000A,
5523 
5524  ShapeElement = 0x0B000000,
5525  PolygonShapeElement = 0x0B000001,
5526  EllipseShapeElement = 0x0B000002,
5527  CircleShapeElement = 0x0B000003,
5528  EllipticalArcShapeElement = 0x0B000004,
5529  AnchorShapeElement = 0x0B000005,
5530  LineShapeElement = 0x0B000006,
5531  CircularArcShapeElement = 0x0B000007,
5532  LeaderLineClippingElement = 0x0B000008,
5533 
5534  MouseState = 0x01001001,
5535  TouchState = 0x01001002,
5536  KeyboardState = 0x01001003,
5537  FontInfoState = 0x01001004,
5538  HighlightState = 0x01001005,
5539 
5540  KeyPath = 0x01000F01,
5541 
5542  Key = 0x10000000,
5543  IncludeKey = 0x10000001,
5544  PortfolioKey = 0x10000002,
5545  StyleKey = 0x10000003,
5546 
5547  SegmentKey = 0x10200000,
5548  WindowKey = 0x10600000,
5549  StandAloneWindowKey = 0x10600001,
5550  OffScreenWindowKey = 0x10600002,
5551  ApplicationWindowKey = 0x10600003,
5552 
5553  GeometryKey = 0x10100000,
5554  ReferenceKey = 0x10100001,
5555  CircleKey = 0x10100002,
5556  CircularArcKey = 0x10100003,
5557  CircularWedgeKey = 0x10100004,
5558  CuttingSectionKey = 0x10100005,
5559  CylinderKey = 0x10100006,
5560  EllipseKey = 0x10100007,
5561  EllipticalArcKey = 0x10100008,
5562  InfiniteLineKey = 0x10100009,
5563  LineKey = 0x1010000a,
5564  DistantLightKey = 0x1010000b,
5565  SpotlightKey = 0x1010000c,
5566  MarkerKey = 0x1010000d,
5567  MeshKey = 0x1010000e,
5568  NURBSCurveKey = 0x1010000f,
5569  NURBSSurfaceKey = 0x10100010,
5570  PolygonKey = 0x10100011,
5571  ShellKey = 0x10100012,
5572  SphereKey = 0x10100013,
5573  TextKey = 0x10100014,
5574  GridKey = 0x10100015,
5575 
5576  Definition = 0x20000000,
5577  NamedStyleDefinition = 0x20000001,
5578  TextureDefinition = 0x20000002,
5579  LinePatternDefinition = 0x20000003,
5580  GlyphDefinition = 0x20000004,
5581  CubeMapDefinition = 0x20000005,
5582  ImageDefinition = 0x20000006,
5583  MaterialPaletteDefinition = 0x20000007,
5584  ShaderDefinition = 0x20000008,
5585  ShapeDefinition = 0x20000009,
5586 
5587  Control = 0x50000000,
5588  CameraControl = 0x50000001,
5589  SelectabilityControl = 0x50000002,
5590  MarkerAttributeControl = 0x50000003,
5591  SphereAttributeControl = 0x50000004,
5592  LightingAttributeControl = 0x50000005,
5593  CylinderAttributeControl = 0x50000006,
5594  TextAttributeControl = 0x50000007,
5595  LineAttributeControl = 0x50000008,
5596  EdgeAttributeControl = 0x50000009,
5597  CurveAttributeControl = 0x5000000a,
5598  ModellingMatrixControl = 0x5000000b,
5599  TextureMatrixControl = 0x5000000c,
5600  CullingControl = 0x5000000d,
5601  TransparencyControl = 0x5000000e,
5602  MaterialMappingControl = 0x5000000f,
5603  NURBSSurfaceAttributeControl = 0x50000010,
5604  PostProcessEffectsControl = 0x50000011,
5605  BoundingControl = 0x50000012,
5606  VisualEffectsControl = 0x50000013,
5607  SelectionOptionsControl = 0x50000014,
5608  HighlightOptionsControl = 0x50000015,
5609  DefinitionControl = 0x50000016,
5610  SelectionControl = 0x50000017,
5611  HighlightControl = 0x50000018,
5612  StandAloneWindowOptionsControl = 0x50600019, //Is a Window Key
5613  OffScreenWindowOptionsControl = 0x5060001a, //Is a Window Key
5614  ApplicationWindowOptionsControl = 0x5060001b, //Is a Window Key
5615  VisibilityControl = 0x5000001c,
5616  SubwindowControl = 0x5000001d,
5617  PerformanceControl = 0x5000001e,
5618  HiddenLineAttributeControl = 0x5000001f,
5619  DrawingAttributeControl = 0x50000020,
5620  DebuggingControl = 0x50000021,
5621  ContourLineControl = 0x50000022,
5622  StyleControl = 0x50000023,
5623  ConditionControl = 0x50000024,
5624  PortfolioControl = 0x50000025,
5625  WindowInfoControl = 0x50000026,
5626  AttributeLockControl = 0x50000027,
5627  TransformMaskControl = 0x50000028,
5628  ColorInterpolationControl = 0x50000029,
5629  UpdateOptionsControl = 0x50600030, //Is a Window Key
5630  CuttingSectionAttributeControl = 0x50000031,
5631 
5632  LibraryMask = 0x80FF0000,
5633 
5634  Sprocket = 0x80000000,
5635  Canvas = 0x80000001,
5636  Layout = 0x80000002,
5637  View = 0x80000003,
5638  Model = 0x80000004,
5639  Operator = 0x80000005,
5640  SprocketPath = 0x80000007,
5641 
5642  SprocketControl = 0xD0000000,
5643  OperatorControl = 0xD0000008,
5644  NavigationCubeControl = 0xD0000009,
5645  AxisTriadControl = 0xD000000A,
5646 
5647  SprocketKit = 0x81000000,
5648 
5649  Metadata = 0x80001000,
5650  IntegerMetadata = 0x80001001,
5651  UnsignedIntegerMetadata = 0x80001002,
5652  DoubleMetadata = 0x80001003,
5653  StringMetadata = 0x80001004,
5654  TimeMetadata = 0x80001005,
5655  BooleanMetadata = 0x80001006,
5656 
5657  Component = 0x80000200,
5658  Filter = 0x80000600,
5659  Capture = 0x80000a00,
5660  CADModel = 0x80000300,
5661  ComponentPath = 0x81001000,
5662 
5663  ExchangeMask = 0x80020000,
5664  ExchangeComponent = 0x80021200,
5665  ExchangeSheet = 0x80021201,
5666  ExchangeProductOccurrence = 0x80021202,
5667  ExchangeFilter = 0x80020601,
5668  ExchangeCapture = 0x80020a01,
5669  ExchangeCADModel = 0x80020301,
5670  ExchangeConfiguration = 0x81020001,
5671  ExchangeImportOptionsKit = 0x81020002,
5672  ExchangeExportACISOptionsKit = 0x81020003,
5673  ExchangeExportIGESOptionsKit = 0x81020004,
5674  ExchangeExportJTOptionsKit = 0x81020005,
5675  ExchangeExportParasolidOptionsKit = 0x81020006,
5676  ExchangeExportPRCOptionsKit = 0x81020007,
5677  ExchangeExportSTEPOptionsKit = 0x81020008,
5678  ExchangeExportSTLOptionsKit = 0x81020009,
5679  ExchangeExportU3DOptionsKit = 0x8102000a,
5680  ExchangeExportXMLOptionsKit = 0x8102000b,
5681  ExchangeTessellationOptionsKit = 0x8102000c,
5682  ExchangeModelFileImportOptionsKit = 0x8102000d,
5683  ExchangeTranslationOptionsKit = 0x8102000e,
5684  ExchangeNURBSConversionOptionsKit = 0x8102000f,
5685  ExchangeExport3MFOptionsKit = 0x81020010,
5686 
5687  PublishMask = 0x80040000,
5688  PublishDocumentKit = 0x81040001,
5689  PublishPageKit = 0x81040002,
5690  PublishTemplateKit = 0x81040003,
5691  PublishAnnotationKit = 0x81040004,
5692  PublishArtworkKit = 0x81040005,
5693  PublishViewKit = 0x81040006,
5694  PublishTextKit = 0x81040007,
5695  PublishImageKit = 0x81040008,
5696  PublishTableKit = 0x81040009,
5697  PublishExportOptionsKit = 0x8104000a,
5698  PublishLinkKit = 0x8104000b,
5699  PublishButtonKit = 0x8104000c,
5700  PublishTextFieldKit = 0x8104000d,
5701  PublishSlideTableKit = 0x8104000e,
5702  PublishCheckBoxKit = 0x8104000f,
5703  PublishRadioButtonKit = 0x81040010,
5704  PublishListBoxKit = 0x81040011,
5705  PublishDropDownListKit = 0x81040012,
5706  PublishSignatureFieldKit = 0x81040013,
5707 
5708  PublishDocumentKey = 0x80040001,
5709  PublishPageControl = 0x80040002,
5710 
5711  ExchangeParasolidMask = 0x80080000,
5712 
5713  SceneTree = 0x80008001,
5714  SceneTreeItem = 0x80008002,
5715 
5716  ComponentTree = 0x80008003,
5717  ComponentTreeItem = 0x80008004,
5718 
5719  SketchupMask = 0x80100000,
5720  SketchupImportOptionsKit = 0x81100001,
5721  SketchupImportResultsKit = 0x81100002,
5722 
5723  ParasolidMask = 0x80200000,
5724  ParasolidComponent = 0x80201201,
5725  ParasolidCADModel = 0x80200302,
5726  ParasolidImportOptionsKit = 0x81200003,
5727  ParasolidFacetTessellationKit = 0x81200004,
5728  ParasolidLineTessellationKit = 0x81200005,
5729  ParasolidExportOptionsKit = 0x81200006,
5730 
5731  DWGMask = 0x80400000,
5732  DWGComponent = 0x80401201,
5733  DWGLayer = 0x80401202,
5734  DWGLayout = 0x80400a03,
5735  DWGCADModel = 0x80400304,
5736  DWGImportOptionsKit = 0x81400005,
5737 
5738  OOCMask = 0x80800000,
5739  OOCImportOptionsKit = 0x81800001,
5740  OOCImportResultsKit = 0x81800002,
5741 
5742  HTMLMask = 0x80010000,
5743 
5744 
5745  IONotifierData = 0x84000200,
5746  StreamImportNotifierData = 0x84000201,
5747  STLImportNotifierData = 0x84000202,
5748  OBJImportNotifierData = 0x84000203,
5749  ExchangeImportNotifierData = 0x84020204,
5750  SketchupImportNotifierData = 0x84100205,
5751  ParasolidImportNotifierData = 0x84200206,
5752  ExchangeTranslationNotifierData = 0x84020207,
5753  ExchangeExportNotifierData = 0x84020208,
5754  StreamExportNotifierData = 0x84000209,
5755  DWGImportNotifierData = 0x8440020a,
5756  ExchangeParasolidImportNotifierData = 0x8408020b,
5757  PointCloudImportNotifierData = 0x8400020c,
5758  OOCImportNotifierData = 0x8480020d,
5759  OBJExportNotifierData = 0x8400020e,
5760 };
5761 
5763 class HPS_API Memory
5764 {
5765 public:
5771  static void * Allocate(size_t in_bytes, bool in_clear_memory = true);
5772 
5773 
5778  static void Free(void * in_pointer);
5779 
5780 private:
5782  Memory();
5783 };
5784 
5785 
5787 template <typename T>
5788 class NO_HPS_API Allocator
5789 {
5790 public:
5791  typedef T value_type;
5792  typedef value_type * pointer;
5793  typedef value_type const * const_pointer;
5794  typedef value_type & reference;
5795  typedef value_type const & const_reference;
5796  typedef size_t size_type;
5797  typedef ptrdiff_t difference_type;
5798 
5799 
5800  Allocator() {}
5801  Allocator(Allocator<T> const & in_that) { HPS_UNREFERENCED(in_that); }
5802  ~Allocator() {}
5803 
5804  template <typename U> Allocator(Allocator<U> const &) {}
5805 
5806  template <typename U>
5807  struct rebind
5808  {
5809  typedef Allocator<U> other;
5810  };
5811 
5812 
5813  pointer address(reference x) const { return &x; }
5814  const_pointer address(const_reference x) const { return &x; }
5815 
5816  pointer allocate(size_type n, void * v = 0) { HPS_UNREFERENCED(v); return static_cast<pointer>(Memory::Allocate(n * sizeof(T))); }
5817  void deallocate(pointer p, size_type n) { HPS_UNREFERENCED(n); Memory::Free(p); }
5818 
5819 #if defined(_MSC_VER) || defined (__APPLE__)
5820  void construct(pointer p, const_reference x) { new(p) T(x); }
5821  void construct(pointer p, value_type && x) { new(p) T(std::move(x)); }
5822 #else
5823  template<typename U, typename... Args>
5824  void construct(U * p, Args&&... args) { new(p) U(std::forward<Args>(args)...); }
5825 #endif
5826  void destroy(pointer p) { HPS_UNREFERENCED(p); p->~T(); }
5827 
5828  size_type max_size() const { return static_cast<size_type>(-1) / sizeof(T); }
5829 };
5830 
5831 template <typename T, typename U>
5832 bool operator==(const Allocator<T> &, const Allocator<U> &) { return true; }
5833 
5834 template <typename T, typename U>
5835 bool operator!=(const Allocator<T> &, const Allocator<U> &) { return false; }
5836 
5838 class Exception : public std::runtime_error
5839 {
5840 public:
5841  Exception(char const * in_info) : std::runtime_error(in_info) { }
5842 };
5843 
5844 
5847 {
5848 public:
5849  InvalidObjectException(char const * in_info = "Attempted to use a deleted, uninitialized, or otherwise invalid object.") :
5850  Exception(in_info) {}
5851 };
5852 
5853 
5857 {
5858 public:
5859  IndexOutOfRangeException(char const * in_info = "Attempted to access an element outside the bounds of the array.") :
5860  Exception(in_info) {}
5861 };
5862 
5863 
5866 {
5867 public:
5868  InvalidSpecificationException(char const * in_info = "Missing or invalid specification.") :
5869  Exception(in_info) {}
5870 };
5871 
5872 
5875 {
5876 public:
5877  InvalidLicenseException(char const * in_info) :
5878  Exception(in_info) {}
5879 };
5880 
5881 
5884 {
5885 public:
5886  InvalidOperationException(char const * in_info = "Operation not supported on this platform.") :
5887  Exception(in_info) {}
5888 };
5889 
5891 class IOException : public Exception
5892 {
5893 public:
5897  IOException(char const * in_info, IOResult in_result)
5898  : Exception(in_info), result(in_result) {}
5899 
5900  IOResult result;
5901 };
5902 
5903 
5905 class HPS_API Object
5906 {
5907 public:
5908 
5909  Object();
5910 
5911  Object(Object const & that);
5912 
5913  virtual ~Object();
5914 
5915  Object & operator=(Object const & other_object);
5916 
5920  Object(Object && in_that);
5921 
5922 
5926  Object & operator=(Object && in_that);
5927 
5934  virtual HPS::Type Type() const;
5935 
5937  static const HPS::Type staticType = HPS::Type::None;
5938 
5941  virtual HPS::Type ObjectType() const { return staticType; }
5942 
5947  virtual bool Empty() const {return (impl_ == 0);};
5948 
5950  virtual void Reset();
5951 
5958  bool HasType(HPS::Type in_mask) const;
5959 
5962  intptr_t GetClassID() const;
5963 
5969  intptr_t GetInstanceID() const;
5970 
5973  template <typename T>
5974  static intptr_t ClassID()
5975  {
5976  static const intptr_t ret = T().GetClassID();
5977  return ret;
5978  }
5979 private:
5980 
5981  friend class HPSI::Impl;
5982  friend class HPSI::KeyImpl;
5983  friend class HPSI::TicketImpl;
5984 
5985  HPSI::Impl * impl_;
5986 };
5987 
5988 
5990 class HPS_API Control : public Object
5991 {
5992 public:
5993  virtual HPS::Type Type() const { return ObjectType(); }
5994  static const HPS::Type staticType = HPS::Type::Control;
5995  HPS::Type ObjectType() const { return staticType; }
5996 
5997 #if !defined(_MSC_VER) || _MSC_VER >= 1900
5998  Control(Control const & in_that) = default;
5999 #endif
6000 
6001 protected:
6002  Control() {}
6003 
6007  Control(Control && in_that) : Object(std::move(in_that)) {}
6008 
6012  Control & operator=(Control && in_that)
6013  {
6014  this->Object::operator=(std::move(in_that));
6015  return *this;
6016  }
6017 };
6018 
6019 
6021 class HPS_API Kit : public Object
6022 {
6023 public:
6024  static const HPS::Type staticType = HPS::Type::Kit;
6025  HPS::Type ObjectType() const { return staticType; }
6026  virtual HPS::Type Type() const { return ObjectType(); }
6027 
6028 #if !defined(_MSC_VER) || _MSC_VER >= 1900
6029  Kit(Kit const & in_that) = default;
6030 #endif
6031 
6032 protected:
6033  Kit() {}
6034 
6038  Kit(Kit && in_that) : Object(std::move(in_that)) {}
6039 
6043  Kit & operator=(Kit && in_that)
6044  {
6045  this->Object::operator=(std::move(in_that));
6046  return *this;
6047  }
6048 };
6049 
6050 
6052 class HPS_API ObjectPoint : public Point
6053 {
6054 public:
6055 
6057  ObjectPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
6058 
6060  ObjectPoint(Point const & in_point):Point(in_point){}
6061 
6063  ObjectPoint(WindowKey const & in_window, ObjectPoint const & in_point);
6064 
6066  ObjectPoint(WindowKey const & in_window, WorldPoint const & in_point);
6067 
6069  ObjectPoint(WindowKey const & in_window, CameraPoint const & in_point);
6070 
6072  ObjectPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
6073 
6075  ObjectPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
6076 
6078  ObjectPoint(WindowKey const & in_window, WindowPoint const & in_point);
6079 
6081  ObjectPoint(WindowKey const & in_window, PixelPoint const & in_point);
6082 
6083 private:
6084 
6085  ObjectPoint(WorldPoint const & in_point); // Prevent implicit conversion to other types of points
6086  ObjectPoint(CameraPoint const & in_point); // Prevent implicit conversion to other types of points
6087  ObjectPoint(InnerWindowPoint const & in_point); // Prevent implicit conversion to other types of points
6088  ObjectPoint(InnerPixelPoint const & in_point); // Prevent implicit conversion to other types of points
6089  ObjectPoint(WindowPoint const & in_point); // Prevent implicit conversion to other types of points
6090  ObjectPoint(PixelPoint const & in_point); // Prevent implicit conversion to other types of points
6091 
6092 };
6093 
6095 class HPS_API WorldPoint : public Point
6096 {
6097 public:
6099  WorldPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
6100 
6102  WorldPoint(Point const & in_point):Point(in_point){}
6103 
6105  WorldPoint(WindowKey const & in_window, ObjectPoint const & in_point);
6106 
6108  WorldPoint(WindowKey const & in_window, WorldPoint const & in_point);
6109 
6111  WorldPoint(WindowKey const & in_window, CameraPoint const & in_point);
6112 
6114  WorldPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
6115 
6117  WorldPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
6118 
6120  WorldPoint(WindowKey const & in_window, WindowPoint const & in_point);
6121 
6123  WorldPoint(WindowKey const & in_window, PixelPoint const & in_point);
6124 
6125 private:
6126 
6127  WorldPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
6128  WorldPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
6129  WorldPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
6130  WorldPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
6131  WorldPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
6132  WorldPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
6133 
6134 };
6135 
6137 class HPS_API CameraPoint : public Point
6138 {
6139 public:
6141  CameraPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
6142 
6144  CameraPoint(Point const & in_point):Point(in_point){}
6145 
6147  CameraPoint(WindowKey const & in_window, ObjectPoint const & in_point);
6148 
6150  CameraPoint(WindowKey const & in_window, WorldPoint const & in_point);
6151 
6153  CameraPoint(WindowKey const & in_window, CameraPoint const & in_point);
6154 
6156  CameraPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
6157 
6159  CameraPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
6160 
6162  CameraPoint(WindowKey const & in_window, WindowPoint const & in_point);
6163 
6165  CameraPoint(WindowKey const & in_window, PixelPoint const & in_point);
6166 
6167 private:
6168  CameraPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
6169  CameraPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
6170  CameraPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
6171  CameraPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
6172  CameraPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
6173  CameraPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
6174 
6175 };
6176 
6178 class HPS_API InnerWindowPoint : public Point
6179 {
6180 public:
6181 
6183  InnerWindowPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
6184 
6186  InnerWindowPoint(Point const & in_point):Point(in_point){}
6187 
6189  InnerWindowPoint(WindowKey const & in_window, ObjectPoint const & in_point);
6190 
6192  InnerWindowPoint(WindowKey const & in_window, WorldPoint const & in_point);
6193 
6195  InnerWindowPoint(WindowKey const & in_window, CameraPoint const & in_point);
6196 
6198  InnerWindowPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
6199 
6201  InnerWindowPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
6202 
6204  InnerWindowPoint(WindowKey const & in_window, WindowPoint const & in_point);
6205 
6207  InnerWindowPoint(WindowKey const & in_window, PixelPoint const & in_point);
6208 
6209 private:
6210  InnerWindowPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
6211  InnerWindowPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
6212  InnerWindowPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
6213  InnerWindowPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
6214  InnerWindowPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
6215  InnerWindowPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
6216 };
6217 
6219 class HPS_API InnerPixelPoint : public Point
6220 {
6221 public:
6222 
6224  InnerPixelPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
6225 
6227  InnerPixelPoint(Point const & in_point):Point(in_point){}
6228 
6230  InnerPixelPoint(WindowKey const & in_window, ObjectPoint const & in_point);
6231 
6233  InnerPixelPoint(WindowKey const & in_window, WorldPoint const & in_point);
6234 
6236  InnerPixelPoint(WindowKey const & in_window, CameraPoint const & in_point);
6237 
6239  InnerPixelPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
6240 
6242  InnerPixelPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
6243 
6245  InnerPixelPoint(WindowKey const & in_window, WindowPoint const & in_point);
6246 
6248  InnerPixelPoint(WindowKey const & in_window, PixelPoint const & in_point);
6249 
6250 private:
6251  InnerPixelPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
6252  InnerPixelPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
6253  InnerPixelPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
6254  InnerPixelPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
6255  InnerPixelPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
6256  InnerPixelPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
6257 
6258 };
6259 
6261 class HPS_API WindowPoint : public Point
6262 {
6263 public:
6264 
6266  WindowPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
6267 
6269  WindowPoint(Point const & in_point):Point(in_point){}
6270 
6272  WindowPoint(WindowKey const & in_window, ObjectPoint const & in_point);
6273 
6275  WindowPoint(WindowKey const & in_window, WorldPoint const & in_point);
6276 
6278  WindowPoint(WindowKey const & in_window, CameraPoint const & in_point);
6279 
6281  WindowPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
6282 
6284  WindowPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
6285 
6287  WindowPoint(WindowKey const & in_window, WindowPoint const & in_point);
6288 
6290  WindowPoint(WindowKey const & in_window, PixelPoint const & in_point);
6291 
6292 private:
6293  WindowPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
6294  WindowPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
6295  WindowPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
6296  WindowPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
6297  WindowPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
6298  WindowPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
6299 };
6300 
6301 
6303 class HPS_API PixelPoint : public Point
6304 {
6305 public:
6307  PixelPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
6308 
6310  PixelPoint(Point const & in_point):Point(in_point){}
6311 
6313  PixelPoint(WindowKey const & in_window, ObjectPoint const & in_point);
6314 
6316  PixelPoint(WindowKey const & in_window, WorldPoint const & in_point);
6317 
6319  PixelPoint(WindowKey const & in_window, CameraPoint const & in_point);
6320 
6322  PixelPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
6323 
6325  PixelPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
6326 
6328  PixelPoint(WindowKey const & in_window, WindowPoint const & in_point);
6329 
6331  PixelPoint(WindowKey const & in_window, PixelPoint const & in_point);
6332 
6333 private:
6334  PixelPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
6335  PixelPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
6336  PixelPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
6337  PixelPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
6338  PixelPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
6339  PixelPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
6340 
6341 };
6342 
6345 class HPS_API Event
6346 {
6347 public:
6351  enum class Status : uint32_t
6352  {
6353  InProgress,
6354  Completed,
6355  Failed
6356  };
6357 
6359  Event(intptr_t in_channel = 0): channel(in_channel), consumable(true), time_stamp(0) {}
6360 
6361  virtual ~Event();
6362 
6364  intptr_t GetClassID() const;
6365 
6368  virtual Event * Clone() const=0;
6369 
6371  virtual bool Drop(Event const * in_that_event) const { HPS_UNREFERENCED(in_that_event); return false; }
6372 
6375  virtual intptr_t Freshen() const { return 0; }
6376 
6378  intptr_t GetChannel() const { return channel; }
6379 
6381  Time GetTimeStamp() const { return time_stamp; }
6382 
6384  bool IsConsumable() const { return consumable; }
6385 
6386  static void * operator new (size_t in_size) { return Memory::Allocate(in_size); }
6387  static void operator delete (void * in_ptr, size_t in_size) throw () { HPS_UNREFERENCED(in_size); Memory::Free(in_ptr); }
6388 
6389 protected:
6390  intptr_t channel;
6391  bool consumable;
6392 
6393 private:
6394  friend class HPSI::EventDispatcherImpl;
6395  Time time_stamp;
6396 };
6397 
6398 
6401 class HPS_API EventNotifier : public Object
6402 {
6403 public:
6404 
6406  EventNotifier();
6407 
6410  EventNotifier(EventNotifier const & in_that);
6411 
6415  EventNotifier(EventNotifier && in_that);
6416 
6420  EventNotifier & operator=(EventNotifier && in_that);
6421 
6422  virtual ~EventNotifier();
6423 
6424  static const HPS::Type staticType = HPS::Type::EventNotifier;
6425  HPS::Type ObjectType() const {return staticType;};
6426 
6430  EventNotifier & operator=(EventNotifier const & in_that);
6431 
6434  virtual void Assign(EventNotifier const & in_that);
6435 
6438  EventNotifier const & Wait() const;
6439 
6442  Event::Status Status() const;
6443 };
6444 
6446 enum class KeyboardCode : uint32_t
6447 {
6448  None = 0,
6449 
6450  Backspace = 8,
6451  Tab = 9,
6452  Clear = 11,
6453  Return = 13,
6454  Shift = 16,
6455  Control = 17,
6456  Alt = 18,
6457  Pause = 19,
6458  Escape = 27,
6459 
6460  Space = 32,
6461  ExclamationMark,
6462  DoubleQuote,
6463  Number,
6464  Dollar,
6465  Percent,
6466  Ampersand,
6467  SingleQuote,
6468  OpenParen,
6469  CloseParen,
6470 
6471  Asterisk,
6472  Plus,
6473  Comma,
6474  Hyphen,
6475  Period,
6476  Slash,
6477 
6478  D0,
6479  D1,
6480  D2,
6481  D3,
6482  D4,
6483  D5,
6484  D6,
6485  D7,
6486  D8,
6487  D9,
6488 
6489  Colon,
6490  Semicolon,
6491  LessThan,
6492  Equal,
6493  GreaterThan,
6494  QuestionMark,
6495  AtSymbol,
6496 
6497  A,
6498  B,
6499  C,
6500  D,
6501  E,
6502  F,
6503  G,
6504  H,
6505  I,
6506  J,
6507  K,
6508  L,
6509  M,
6510  N,
6511  O,
6512  P,
6513  Q,
6514  R,
6515  S,
6516  T,
6517  U,
6518  V,
6519  W,
6520  X,
6521  Y,
6522  Z,
6523 
6524  OpenBrackets,
6525  Backslash,
6526  CloseBrackets,
6527  Caret,
6528  Underscore,
6529  Backtick,
6530 
6531  a,
6532  b,
6533  c,
6534  d,
6535  e,
6536  f,
6537  g,
6538  h,
6539  i,
6540  j,
6541  k,
6542  l,
6543  m,
6544  n,
6545  o,
6546  p,
6547  q,
6548  r,
6549  s,
6550  t,
6551  u,
6552  v,
6553  w,
6554  x,
6555  y,
6556  z,
6557 
6558  OpenBrace,
6559  VerticalBar,
6560  ClosingBrace,
6561  Tilde,
6562  Delete,
6563 
6564  Insert=1024,
6565  Home,
6566  End,
6567  PageUp,
6568  PageDown,
6569 
6570  Help,
6571 
6572  Left,
6573  Up,
6574  Right,
6575  Down,
6576 
6577  NumPad0,
6578  NumPad1,
6579  NumPad2,
6580  NumPad3,
6581  NumPad4,
6582  NumPad5,
6583  NumPad6,
6584  NumPad7,
6585  NumPad8,
6586  NumPad9,
6587 
6588  F1,
6589  F2,
6590  F3,
6591  F4,
6592  F5,
6593  F6,
6594  F7,
6595  F8,
6596  F9,
6597  F10,
6598  F11,
6599  F12,
6600  F13,
6601  F14,
6602  F15,
6603  F16,
6604  F17,
6605  F18,
6606  F19,
6607  F20,
6608  F21,
6609  F22,
6610  F23,
6611  F24,
6612 
6613  CapsLock,
6614  NumLock,
6615  ScrollLock,
6616  LeftShift,
6617  RightShift,
6618  LeftCtrl,
6619  RightCtrl,
6620  LeftAlt,
6621  RightAlt,
6622 
6623  Select,
6624  Print,
6625  Execute,
6626  PrintScreen,
6627 };
6628 
6629 
6631 class NO_HPS_API Touch
6632 {
6633 public:
6634 
6637  Touch() : ID(0), Location(Point(0,0,0)), TapCount(0) {}
6638 
6643  Touch(TouchID in_id, WindowPoint const & in_location, size_t in_tap_count = 1)
6644  : ID(in_id), Location(in_location), TapCount(in_tap_count) {}
6645 
6649  inline bool operator==(Touch const & in_that) const
6650  {
6651  return (ID == in_that.ID && Location == in_that.Location && TapCount == in_that.TapCount);
6652  }
6653 
6657  inline bool operator!=(Touch const & in_that) const
6658  {
6659  return !(*this == in_that);
6660  }
6661 
6662  TouchID ID;
6664  size_t TapCount;
6665 };
6672 typedef std::vector<Point, Allocator<Point> > PointArray;
6673 typedef std::vector<ObjectPoint, Allocator<ObjectPoint> > ObjectPointArray;
6674 typedef std::vector<WorldPoint, Allocator<WorldPoint> > WorldPointArray;
6675 typedef std::vector<CameraPoint, Allocator<CameraPoint> > CameraPointArray;
6676 typedef std::vector<InnerWindowPoint, Allocator<InnerWindowPoint> > InnerWindowPointArray;
6677 typedef std::vector<InnerPixelPoint, Allocator<InnerPixelPoint> > InnerPixelPointArray;
6678 typedef std::vector<WindowPoint, Allocator<WindowPoint> > WindowPointArray;
6679 typedef std::vector<PixelPoint, Allocator<PixelPoint> > PixelPointArray;
6680 typedef std::vector<Vector, Allocator<Vector> > VectorArray;
6681 typedef std::vector<DVector, Allocator<DVector> > DVectorArray;
6682 typedef std::vector<Plane, Allocator<Plane> > PlaneArray;
6683 typedef std::vector<int, Allocator<int> > IntArray;
6684 typedef std::vector<RGBColor, Allocator<RGBColor> > RGBColorArray;
6685 typedef std::vector<RGBAColor, Allocator<RGBAColor> > RGBAColorArray;
6686 typedef std::vector<unsigned int, Allocator<unsigned int> > UnsignedIntArray;
6687 typedef std::vector<size_t, Allocator<size_t> > SizeTArray;
6688 typedef std::vector<float, Allocator<float> > FloatArray;
6689 typedef std::vector<SegmentKey, Allocator<SegmentKey> > SegmentKeyArray;
6690 typedef std::vector<WindowKey, Allocator<WindowKey> > WindowKeyArray;
6691 typedef std::vector<EventHandler, Allocator<EventHandler> > EventHandlerArray;
6692 typedef std::vector<GlyphElement, Allocator<GlyphElement> > GlyphElementArray;
6693 typedef std::vector<ShapeElement, Allocator<ShapeElement> > ShapeElementArray;
6694 typedef std::vector<GlyphPoint, Allocator<GlyphPoint> > GlyphPointArray;
6695 typedef std::vector<UTF8, Allocator<UTF8> > UTF8Array;
6696 typedef std::vector<UTF8Array, Allocator<UTF8Array> > UTF8ArrayArray;
6697 typedef std::vector<bool, Allocator<bool> > BoolArray;
6698 typedef std::vector<TrimKit, Allocator<TrimKit> > TrimKitArray;
6699 typedef std::vector<Key, Allocator<Key> > KeyArray;
6700 typedef std::vector<PortfolioKey, Allocator<PortfolioKey> > PortfolioKeyArray;
6701 typedef std::vector<char, Allocator<char> > CharArray;
6702 typedef std::vector<wchar_t, Allocator<wchar_t> > WCharArray;
6703 typedef std::vector<byte, Allocator<byte> > ByteArray;
6704 typedef std::vector<ByteArray, Allocator<ByteArray> > ByteArrayArray;
6705 typedef std::vector<sbyte, Allocator<sbyte> > SByteArray;
6706 typedef std::vector<MaterialKit, Allocator<MaterialKit> > MaterialKitArray;
6707 typedef std::vector<LinePatternElement, Allocator<LinePatternElement> > LinePatternElementArray;
6708 typedef std::vector<LinePatternParallelKit, Allocator<LinePatternParallelKit> > LinePatternParallelKitArray;
6709 typedef std::vector<Material::Type, Allocator<Material::Type> > MaterialTypeArray;
6710 typedef std::vector<Search::Type, Allocator<Search::Type> > SearchTypeArray;
6711 typedef std::vector<Line::SizeUnits, Allocator<Line::SizeUnits> > LineSizeUnitsArray;
6712 typedef std::vector<CameraKit, Allocator<CameraKit> > CameraKitArray;
6713 typedef std::vector<ConditionalExpression, Allocator<ConditionalExpression> > ConditionalExpressionArray;
6714 typedef std::vector<TextureDefinition, Allocator<TextureDefinition> > TextureDefinitionArray;
6715 typedef std::vector<CubeMapDefinition, Allocator<CubeMapDefinition> > CubeMapDefinitionArray;
6716 typedef std::vector<ImageDefinition, Allocator<ImageDefinition> > ImageDefinitionArray;
6717 typedef std::vector<NamedStyleDefinition, Allocator<NamedStyleDefinition> > NamedStyleDefinitionArray;
6718 typedef std::vector<MaterialPaletteDefinition, Allocator<MaterialPaletteDefinition> > MaterialPaletteDefinitionArray;
6719 typedef std::vector<GlyphDefinition, Allocator<GlyphDefinition> > GlyphDefinitionArray;
6720 typedef std::vector<LinePatternDefinition, Allocator<LinePatternDefinition> > LinePatternDefinitionArray;
6721 typedef std::vector<ShaderDefinition, Allocator<ShaderDefinition> > ShaderDefinitionArray;
6722 typedef std::vector<ShapeDefinition, Allocator<ShapeDefinition> > ShapeDefinitionArray;
6723 typedef std::vector<IntRectangle, Allocator<IntRectangle> > IntRectangleArray;
6724 typedef std::vector<AttributeLock::Type, Allocator<AttributeLock::Type> > AttributeLockTypeArray;
6725 typedef std::vector<Style::Type, Allocator<Style::Type> > StyleTypeArray;
6726 typedef std::vector<TrimElement, Allocator<TrimElement> > TrimElementArray;
6727 typedef std::vector<KeyPath, Allocator<KeyPath> > KeyPathArray;
6728 typedef std::vector<IncludeKey, Allocator<IncludeKey> > IncludeKeyArray;
6729 typedef std::vector<KeyboardCode, Allocator<KeyboardCode> > KeyboardCodeArray;
6730 typedef std::vector<Touch, Allocator<Touch> > TouchArray;
6731 typedef std::vector<ReferenceKey, Allocator<ReferenceKey> > ReferenceKeyArray;
6732 typedef std::vector<intptr_t, Allocator<intptr_t> > IntPtrTArray;
6733 typedef std::vector<GeometryKey, Allocator<GeometryKey> > GeometryKeyArray;
6734 typedef std::vector<Shell::Relation, Allocator<Shell::Relation> > ShellRelationArray;
6735 typedef std::vector<StyleKey, Allocator<StyleKey> > StyleKeyArray;
6736 typedef std::vector<PointArray, Allocator<PointArray> > PointArrayArray;
6737 typedef std::vector<Text::MarginUnits, Allocator<Text::MarginUnits> > TextMarginUnitsArray;
6738 typedef std::vector<PointArrayArray, Allocator<PointArrayArray> > PointArrayArrayArray;
6739 typedef std::vector<Drawing::ClipSpace, Allocator<Drawing::ClipSpace> > ClipSpaceArray;
6740 typedef std::vector<Drawing::ClipOperation, Allocator<Drawing::ClipOperation> > ClipOperationArray;
6741 typedef std::vector<MatrixKit, Allocator<MatrixKit> > MatrixKitArray;
6742 typedef std::vector<int32_t, HPS::Allocator<int32_t>> Int32Array;
6743 typedef std::vector<Line::CoordinateSpace, Allocator<Line::CoordinateSpace>> LineCoordinateSpaceArray;
6744 typedef std::vector<Drawing::Overlay, Allocator<Drawing::Overlay>> DrawingOverlayArray;
6745 typedef std::vector<HighlightState, Allocator<HighlightState>> HighlightStateArray;
6746 typedef std::vector<ImageKit, Allocator<ImageKit>> ImageKitArray;
6747 
6752 class HPS_API ShapeCoordinate
6753 {
6754 public:
6756  ShapeCoordinate();
6757 
6761  ShapeCoordinate(float in_x, float in_y);
6762 
6767  ShapeCoordinate(float in_x, float in_y, FloatArray const & in_margins);
6768 
6774  ShapeCoordinate(float in_x, float in_y, size_t in_count, float const in_margins []);
6775 
6780  ShapeCoordinate(float in_x, float in_y, float in_radius);
6781 
6787  ShapeCoordinate(float in_x, float in_y, float in_radius, FloatArray const & in_margins);
6788 
6795  ShapeCoordinate(float in_x, float in_y, float in_radius, size_t in_count, float const in_margins []);
6796 
6800  bool Equals(ShapeCoordinate const & in_that) const;
6801 
6805  bool operator==(ShapeCoordinate const & in_that) const { return Equals(in_that); }
6806 
6810  bool operator!=(ShapeCoordinate const & in_that) const { return !Equals(in_that); }
6811 
6818  ShapeCoordinate & SetMargins(float in_margin_one, float in_margin_two = 0.0f, float in_margin_three = 0.0f, float in_margin_four = 0.0f);
6819 
6823  bool ShowMargins(FloatArray & out_margins) const;
6824 
6827  ShapeCoordinate & UnsetMargins();
6828 
6829  float x;
6830  float y;
6831  float radius;
6832  FloatArray margins;
6833 };
6834 
6837 class HPS_API ShapePoint
6838 {
6839 public:
6841  ShapePoint();
6842 
6846  ShapePoint(ShapeCoordinate const & in_x, ShapeCoordinate const & in_y);
6847 
6854  ShapePoint(float in_x, float in_y);
6855 
6859  bool Equals(ShapePoint const & in_that) const { return (x == in_that.x && y == in_that.y); }
6860 
6864  bool operator==(ShapePoint const & in_that) const { return Equals(in_that); }
6865 
6869  bool operator!=(ShapePoint const & in_that) const { return !Equals(in_that); }
6870 
6871  ShapeCoordinate x;
6872  ShapeCoordinate y;
6873 };
6874 
6875 typedef std::vector<ShapePoint, Allocator<ShapePoint> > ShapePointArray;
6876 
6878 class HPS_API SearchResultsIterator : public Object
6879 {
6880 public:
6881 
6884 
6888  SearchResultsIterator(SearchResultsIterator const & in_search_results_iterator);
6889 
6894 
6898  SearchResultsIterator & operator=(SearchResultsIterator && in_that);
6899 
6901 
6902  static const HPS::Type staticType = HPS::Type::SearchResultsIterator;
6903  HPS::Type ObjectType() const {return staticType;}
6904 
6909  SearchResultsIterator & operator=(SearchResultsIterator const & in_search_results_iterator);
6910 
6915  void Set(SearchResultsIterator const & in_search_results_iterator);
6916 
6918  void Next();
6919 
6922  SearchResultsIterator & operator++();
6923 
6926  SearchResultsIterator operator++(int in_val);
6927 
6930  bool operator==(SearchResultsIterator const & in_search_results_iterator);
6931 
6934  bool operator!=(SearchResultsIterator const & in_search_results_iterator);
6935 
6939  bool IsValid() const;
6940 
6942  void Reset();
6943 
6947  Key GetItem() const;
6948 
6951  Key operator*() const;
6952 
6955  SearchTypeArray GetResultTypes() const;
6956 };
6957 
6959 class HPS_API SearchResults : public Object
6960 {
6961 public:
6963  SearchResults();
6964 
6967  SearchResults(SearchResults const & in_search_results);
6968 
6972  SearchResults(SearchResults && in_that);
6973 
6977  SearchResults & operator=(SearchResults && in_that);
6978 
6980  virtual void Reset();
6981 
6983  ~SearchResults();
6984 
6985  static const HPS::Type staticType = HPS::Type::SearchResults;
6986  HPS::Type ObjectType() const {return staticType;}
6987 
6991  void Assign(SearchResults const & in_search_results);
6992 
6996  SearchResults & operator=(SearchResults const & in_search_results);
6997 
7000  size_t GetCount() const;
7001 
7004  SearchResultsIterator GetIterator() const;
7005 };
7006 
7008 class HPS_API FontSearchResultsIterator : public Object
7009 {
7010 public:
7011 
7014 
7018  FontSearchResultsIterator(FontSearchResultsIterator const & in_search_results_iterator);
7019 
7024 
7029  FontSearchResultsIterator & operator=(FontSearchResultsIterator const & in_search_results_iterator);
7030 
7031 
7035  FontSearchResultsIterator & operator=(FontSearchResultsIterator && in_that);
7036 
7038 
7039  static const HPS::Type staticType = HPS::Type::FontSearchResultsIterator;
7040  HPS::Type ObjectType() const {return staticType;}
7041 
7042 
7047  void Set(FontSearchResultsIterator const & in_search_results_iterator);
7048 
7050  void Next();
7051 
7054  FontSearchResultsIterator & operator++();
7055 
7058  FontSearchResultsIterator operator++(int in_val);
7059 
7062  bool operator==(FontSearchResultsIterator const & in_search_results_iterator);
7063 
7066  bool operator!=(FontSearchResultsIterator const & in_search_results_iterator);
7067 
7071  bool IsValid() const;
7072 
7074  void Reset();
7075 
7079  FontInfoState GetItem() const;
7080 
7083  FontInfoState operator*() const;
7084 
7085 };
7086 
7088 class HPS_API FontSearchResults : public Object
7089 {
7090 public:
7091 
7094 
7097  FontSearchResults(FontSearchResults const & in_search_results);
7098 
7103 
7107  FontSearchResults & operator=(FontSearchResults && in_that);
7108 
7110  virtual void Reset();
7111 
7113  ~FontSearchResults();
7114 
7115  static const HPS::Type staticType = HPS::Type::FontSearchResults;
7116  HPS::Type ObjectType() const {return staticType;}
7117 
7121  void Assign(FontSearchResults const & in_search_results);
7122 
7123 
7127  FontSearchResults & operator=(FontSearchResults const & in_search_results);
7128 
7131  size_t GetCount() const;
7132 
7135  FontSearchResultsIterator GetIterator() const;
7136 };
7137 
7139 class HPS_API UTF8
7140 {
7141 public:
7142 
7144  UTF8();
7145 
7147  ~UTF8();
7148 
7155  UTF8(char const * in_string, char const * in_locale = 0);
7156 
7159  UTF8(wchar_t const * in_string);
7160 
7163  UTF8(UTF8 const & in_that);
7164 
7167  UTF8(UTF8 && in_that);
7168 
7172  UTF8 & Assign(UTF8 && in_utf8);
7173 
7176  inline UTF8 & operator= (UTF8 && in_utf8)
7177  {
7178  return Assign(std::move(in_utf8));
7179  }
7180 
7185  size_t ToWStr(wchar_t * out_wide_string) const;
7186 
7190  size_t ToWStr(WCharArray & out_wide_string) const;
7191 
7194  inline bool IsValid() const
7195  {
7196  return (_length > 0);
7197  }
7198 
7201  inline bool Empty() const
7202  {
7203  return (_length == 0);
7204  }
7205 
7207  void Clear();
7208 
7210  void Reset() { Clear(); }
7211 
7215  inline size_t GetLength() const
7216  {
7217  return _length;
7218  }
7219 
7223  inline size_t GetWStrLength() const
7224  {
7225  return ToWStr(0);
7226  }
7227 
7230  inline char const * GetBytes() const
7231  {
7232  return _text;
7233  }
7234 
7237  inline operator char const * () const
7238  {
7239  return _text;
7240  }
7241 
7244  char At(size_t in_index) const
7245  {
7246  if(!IsValid())
7247  throw InvalidObjectException();
7248  else if(in_index >= _length)
7249  throw IndexOutOfRangeException();
7250  else
7251  return _text[in_index];
7252  }
7253 
7257  UTF8 & Assign(UTF8 const & in_utf8);
7258 
7262  inline UTF8 & operator= (UTF8 const & in_utf8)
7263  {
7264  return Assign(in_utf8);
7265  }
7266 
7270  UTF8 & operator+= (UTF8 const & in_utf8);
7271 
7275  UTF8 & operator+= (char const * in_utf8);
7276 
7280  UTF8 operator+ (UTF8 const & in_utf8) const;
7281 
7285  UTF8 operator+ (char const * in_utf8) const;
7286 
7290  bool operator== (UTF8 const & in_utf8) const;
7291 
7295  bool operator!= (UTF8 const & in_utf8) const
7296  {
7297  return !(*this == in_utf8);
7298  }
7299 
7303  bool operator== (char const * in_utf8) const;
7304 
7308  bool operator!= (char const * in_utf8) const
7309  {
7310  return !(*this == in_utf8);
7311  }
7312 
7317  friend inline bool operator==(char const * in_left, UTF8 const & in_right)
7318  {
7319  return in_right == in_left;
7320  }
7321 
7326  friend inline bool operator!=(char const * in_left, UTF8 const & in_right)
7327  {
7328  return in_right != in_left;
7329  }
7330 
7335  friend inline bool operator==(wchar_t const * in_left, UTF8 const & in_right)
7336  {
7337  return in_right == UTF8(in_left);
7338  }
7339 
7344  friend bool operator!=(wchar_t const * in_left, UTF8 const & in_right)
7345  {
7346  return in_right != UTF8(in_left);
7347  }
7348 
7353  friend inline UTF8 operator+ (char const * in_left, UTF8 const & in_right)
7354  {
7355  return UTF8(in_left, "utf8") + in_right;
7356  }
7357 
7362  friend inline UTF8 operator+ (wchar_t const * in_left, UTF8 const & in_right)
7363  {
7364  return UTF8(in_left) + in_right;
7365  }
7366 
7367 
7370  size_t GetHash() const;
7371 
7372  friend class HPSI::String;
7373 
7374 private:
7375 
7376  size_t internal_encode(wchar_t const * in_wide_string);
7377  static size_t internal_decode(size_t in_length, const char* in_utf8_string, wchar_t * out_wide_string);
7378  size_t internal_decode(wchar_t * out_wide_string) const;
7379 
7380  char * _text;
7381  size_t _length;
7382  mutable size_t _hash_key;
7383  static const size_t _buffer_size = 64 - sizeof(const char *) - 2 * sizeof(size_t);
7384  char _buffer[_buffer_size];
7385 };
7386 
7388 struct UTF8Hasher {
7389  inline size_t operator()(const HPS::UTF8 & in_utf8) const
7390  {
7391  return in_utf8.GetHash();
7392  }
7393 };
7394 
7397 class HPS_API ConditionalExpression : public Object
7398 {
7399 public:
7400 
7403 
7406  ConditionalExpression(char const * in_condition);
7407 
7410  ConditionalExpression(float in_number);
7411 
7414  ConditionalExpression(HPS::Condition::Intrinsic in_special);
7415 
7419 
7424 
7428  ConditionalExpression & operator=(ConditionalExpression && in_that);
7429 
7430  static const HPS::Type staticType = HPS::Type::ConditionalExpression;
7431  HPS::Type ObjectType() const { return staticType; }
7432 
7436  bool ShowCondition(UTF8 & out_condition) const;
7437 
7441  bool ShowNumber(float & out_number) const;
7442 
7446  bool ShowIntrinsic(Condition::Intrinsic & out_special) const;
7447 
7451  bool ShowOperands(ConditionalExpressionArray & out_operands) const;
7452 
7456  ConditionalExpression & operator=(ConditionalExpression const & in_that);
7457 
7461  bool Equals(ConditionalExpression const & in_that) const;
7462 
7466  bool operator==(ConditionalExpression const & in_that) const;
7467 
7471  bool operator!=(ConditionalExpression const & in_that) const;
7472 
7476  bool IsSatisfiedBy(UTF8Array const & in_conditions) const;
7477 
7481  bool IsSatisfiedBy(char const * in_condition) const;
7482 
7486  ConditionalExpression OR(ConditionalExpression const & in_operand2) const;
7487 
7491  ConditionalExpression XOR(ConditionalExpression const & in_operand2) const;
7492 
7496  ConditionalExpression AND(ConditionalExpression const & in_operand2) const;
7497 
7501  ConditionalExpression EQ(ConditionalExpression const & in_operand2) const;
7502 
7506  ConditionalExpression NEQ(ConditionalExpression const & in_operand2) const;
7507 
7511  ConditionalExpression GT(ConditionalExpression const & in_operand2) const;
7512 
7516  ConditionalExpression LT(ConditionalExpression const & in_operand2) const;
7517 
7521  ConditionalExpression GTEQ(ConditionalExpression const & in_operand2) const;
7522 
7526  ConditionalExpression LTEQ(ConditionalExpression const & in_operand2) const;
7527 
7530  ConditionalExpression operator !() const;
7531 
7535  ConditionalExpression operator ||(ConditionalExpression const & in_operand2) const;
7536 
7540  ConditionalExpression operator ^(ConditionalExpression const & in_operand2) const;
7541 
7545  ConditionalExpression operator &&(ConditionalExpression const & in_operand2) const;
7546 
7547 
7551  static ConditionalExpression NOT(ConditionalExpression const & in_operand);
7552 
7557  static ConditionalExpression OR(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7558 
7559 
7564  static ConditionalExpression XOR(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7565 
7570  static ConditionalExpression AND(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7571 
7576  static ConditionalExpression EQ(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7577 
7582  static ConditionalExpression NEQ(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7583 
7588  static ConditionalExpression GT(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7589 
7594  static ConditionalExpression LT(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7595 
7600  static ConditionalExpression GTEQ(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7601 
7606  static ConditionalExpression LTEQ(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7607 
7608  friend HPS_API ConditionalExpression NOT(ConditionalExpression const & in_operand);
7609  friend HPS_API ConditionalExpression OR(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7610  friend HPS_API ConditionalExpression XOR(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7611  friend HPS_API ConditionalExpression AND(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7612 
7613  friend HPS_API ConditionalExpression EQ(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7614  friend HPS_API ConditionalExpression NEQ(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7615  friend HPS_API ConditionalExpression GT(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7616  friend HPS_API ConditionalExpression LT(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7617  friend HPS_API ConditionalExpression GTEQ(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7618  friend HPS_API ConditionalExpression LTEQ(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7619 };
7620 
7621 
7625 HPS_API ConditionalExpression NOT(ConditionalExpression const & in_operand);
7626 
7631 HPS_API ConditionalExpression OR(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7632 
7637 HPS_API ConditionalExpression XOR(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7638 
7643 HPS_API ConditionalExpression AND(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7644 
7649 HPS_API ConditionalExpression EQ(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7650 
7655 HPS_API ConditionalExpression NEQ(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7656 
7661 HPS_API ConditionalExpression GT(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7662 
7667 HPS_API ConditionalExpression LT(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7668 
7673 HPS_API ConditionalExpression GTEQ(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7674 
7679 HPS_API ConditionalExpression LTEQ(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7680 
7681 
7682 
7686 class HPS_API Key : public Object
7687 {
7688 public:
7689 
7691  Key();
7692 
7694  Key(Key const & in_that);
7695 
7697  explicit Key(Control const & in_control);
7698 
7702  Key(Key && in_that);
7703 
7707  Key & operator=(Key && in_that);
7708 
7710  virtual ~Key();
7711 
7712  static const HPS::Type staticType = HPS::Type::Key;
7713  HPS::Type ObjectType() const {return staticType;};
7714 
7716  bool HasOwner() const;
7717 
7719  SegmentKey Up() const;
7720 
7722  SegmentKey Owner() const;
7723 
7725  void Delete();
7726 
7728  void MoveTo(SegmentKey const & in_new_owner);
7729 
7732  Key CopyTo(SegmentKey const & in_destination) const;
7733 
7737  Key & operator=(Key const & in_that);
7738 
7741  virtual void Assign(Key const & in_that);
7742 
7744  bool Equals(Key const & in_that) const;
7745 
7747  bool operator!= (Key const & in_that) const;
7748 
7750  bool operator== (Key const & in_that) const;
7751 
7754  size_t GetHash() const;
7755 };
7756 
7758 struct KeyHasher {
7759  inline size_t operator()(const HPS::Key & in_key) const
7760  {
7761  return in_key.GetHash();
7762  }
7763 };
7764 
7765 
7768 class HPS_API SegmentKey : public Key
7769 {
7770 public:
7772  SegmentKey();
7773 
7775  SegmentKey(SegmentKey const & in_that);
7776 
7778  SegmentKey & operator=(SegmentKey const & other);
7779 
7783  SegmentKey(SegmentKey && in_that);
7784 
7788  SegmentKey & operator=(SegmentKey && in_that);
7789 
7791  explicit SegmentKey(Key const & in_that);
7792 
7794  ~SegmentKey();
7795 
7796  static const HPS::Type staticType = HPS::Type::SegmentKey;
7797  HPS::Type ObjectType() const {return staticType;};
7798 
7800  UTF8 Name() const;
7801 
7804  SegmentKey & SetName(char const * in_name);
7805 
7808  SegmentKey Down(char const * in_segment_name, bool in_create_if_not_present = false) const;
7809 
7812  SegmentKey Subsegment(char const * in_segment_name = "", bool in_create_if_not_present = true) const;
7813 
7815  void Flush(Search::Type in_type_to_remove = Search::Type::Everything, Search::Space in_search_space = Search::Space::SegmentOnly);
7816 
7818  void Flush(SearchTypeArray const & in_types_to_remove, Search::Space in_search_space = Search::Space::SegmentOnly);
7819 
7821  void Flush(size_t in_types_count, Search::Type const in_types_to_remove [], Search::Space in_search_space = Search::Space::SegmentOnly);
7822 
7823 
7824 
7826  size_t Find(Search::Type in_request, Search::Space in_search_space, SearchResults & out_results) const;
7827 
7829  size_t Find(SearchTypeArray const & in_requests, Search::Space in_search_space, SearchResults & out_results) const;
7830 
7832  size_t Find(size_t in_types_count, Search::Type const in_requests [], Search::Space in_search_space, SearchResults & out_results) const;
7833 
7834 
7836  size_t Find(SearchOptionsKit const & in_options, SearchResults & out_results) const;
7837 
7839  size_t Find(SearchOptionsKit const & in_options) const;
7840 
7841 
7844  IncludeKey IncludeSegment(SegmentKey const & in_seg);
7845 
7849  IncludeKey IncludeSegment(SegmentKey const & in_seg, ConditionalExpression const & in_conditional);
7850 
7851 
7857  ReferenceKey ReferenceGeometry(Key const & in_key);
7858 
7866  ReferenceKey ReferenceGeometry(Key const & in_key, ConditionalExpression const & in_conditional);
7867 
7868 
7870  size_t ShowSubsegments() const;
7871 
7873  size_t ShowSubsegments(SegmentKeyArray & out_children) const;
7874 
7878  size_t ShowReferrers(SegmentKeyArray & out_segments) const;
7879 
7883  size_t ShowReferrers(ReferenceKeyArray & out_references) const;
7884 
7888  size_t ShowStylers(SegmentKeyArray & out_segments) const;
7889 
7893  size_t ShowStylers(StyleKeyArray & out_styles) const;
7894 
7898  size_t ShowIncluders(SegmentKeyArray & out_segments) const;
7899 
7903  size_t ShowIncluders(IncludeKeyArray & out_includes) const;
7904 
7905 
7906 
7908  StyleControl GetStyleControl();
7909 
7911  StyleControl const GetStyleControl() const;
7912 
7913 
7915  PortfolioControl GetPortfolioControl();
7916 
7918  PortfolioControl const GetPortfolioControl() const;
7919 
7920 
7922  SegmentKey & SetCondition(char const * in_condition);
7923 
7925  SegmentKey & SetConditions(UTF8Array const & in_conditions);
7926 
7928  SegmentKey & SetConditions(size_t in_count, UTF8 const in_conditions []);
7929 
7931  SegmentKey & UnsetConditions();
7932 
7934  bool ShowConditions(UTF8Array & out_conditions) const;
7935 
7937  ConditionControl GetConditionControl();
7938 
7940  ConditionControl const GetConditionControl() const;
7941 
7942 
7944  SegmentKey & SetMaterialPalette(char const * in_name);
7945 
7947  SegmentKey & UnsetMaterialPalette();
7948 
7950  bool ShowMaterialPalette(UTF8 & out_name) const;
7951 
7952 
7959  SegmentKey & SetPriority(int in_priority);
7960 
7963  SegmentKey & UnsetPriority();
7964 
7968  bool ShowPriority(int & out_priority) const;
7969 
7974  SegmentKey & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
7975 
7981  SegmentKey & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
7982 
7987  SegmentKey & SetUserData(intptr_t in_index, ByteArray const & in_data);
7988 
7992  SegmentKey & UnsetUserData(intptr_t in_index);
7993 
7998  SegmentKey & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
7999 
8003  SegmentKey & UnsetUserData(HPS::IntPtrTArray const & in_indices);
8004 
8007  SegmentKey & UnsetAllUserData();
8008 
8010  size_t ShowUserDataCount() const;
8011 
8016  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
8017 
8021  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
8022 
8027  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
8028 
8029 
8031  LineKey InsertLine(LineKit const & in_kit);
8032 
8034  LineKey InsertLine(size_t in_count, Point const in_pts[]);
8035 
8037  LineKey InsertLine(PointArray const & in_pts);
8038 
8040  LineKey InsertLine(Point const & pt1, Point const & pt2);
8041 
8042 
8044  CylinderKey InsertCylinder(CylinderKit const & in_kit);
8045 
8047  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);
8048 
8050  CylinderKey InsertCylinder(PointArray const & in_points, FloatArray const & in_radii, Cylinder::Capping in_caps = Cylinder::Capping::Both);
8051 
8053  CylinderKey InsertCylinder(Point const & in_point1, Point const & in_point2, float in_radius, Cylinder::Capping in_caps = Cylinder::Capping::Both);
8054 
8055 
8060  SphereKey InsertSphere(SphereKit const & in_kit);
8061 
8069  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));
8070 
8072  CircleKey InsertCircle(CircleKit const & in_kit);
8073 
8075  CircleKey InsertCircle(Point const & in_start, Point const & in_middle, Point const & in_end);
8076 
8078  CircleKey InsertCircle(Point const & in_center, float in_radius, Vector const & in_normal);
8079 
8080 
8082  CircularArcKey InsertCircularArc(CircularArcKit const & in_kit);
8083 
8085  CircularArcKey InsertCircularArc(Point const & in_start, Point const & in_middle, Point const & in_end);
8086 
8087 
8089  CircularWedgeKey InsertCircularWedge(CircularWedgeKit const & in_kit);
8090 
8092  CircularWedgeKey InsertCircularWedge(Point const & in_start, Point const & in_middle, Point const & in_end);
8093 
8094 
8096  EllipseKey InsertEllipse(EllipseKit const & in_kit);
8097 
8099  EllipseKey InsertEllipse(Point const & in_center, Point const & in_major, Point const & in_minor);
8100 
8101 
8103  EllipticalArcKey InsertEllipticalArc(EllipticalArcKit const & in_kit);
8104 
8106  EllipticalArcKey InsertEllipticalArc(Point const & in_center, Point const & in_major, Point const & in_minor, float in_start, float in_end);
8107 
8108 
8110  PolygonKey InsertPolygon(PolygonKit const & in_kit);
8111 
8113  PolygonKey InsertPolygon(PointArray const & in_points);
8114 
8116  PolygonKey InsertPolygon(size_t in_count, Point const in_points []);
8117 
8118 
8120  ShellKey InsertShell(ShellKit const & in_kit);
8121 
8123  ShellKey InsertShell(PointArray const & in_points, IntArray const & in_facelist);
8124 
8126  ShellKey InsertShell(size_t in_point_count, Point const in_points [], size_t in_facelist_count, int const in_facelist []);
8127 
8135  ShellKey InsertShellByTristrips(PointArray const & in_points, IntArray const & in_tristrips);
8136 
8138  ShellKey InsertShellByTristrips(size_t in_point_count, Point const in_points [], size_t in_tristrips_count, int const in_tristrips []);
8139 
8141  MeshKey InsertMesh(MeshKit const & in_kit);
8142 
8144  MeshKey InsertMesh(size_t in_rows, size_t in_columns, PointArray const & in_points);
8145 
8147  MeshKey InsertMesh(size_t in_rows, size_t in_columns, size_t in_point_count, Point const in_points []);
8148 
8149 
8151  MarkerKey InsertMarker(Point const & in_position);
8152 
8154  MarkerKey InsertMarker(MarkerKit const & in_kit);
8155 
8156 
8158  DistantLightKey InsertDistantLight(Vector const & in_direction);
8159 
8161  DistantLightKey InsertDistantLight(DistantLightKit const & in_kit);
8162 
8163 
8165  CuttingSectionKey InsertCuttingSection(Plane const & in_plane);
8166 
8168  CuttingSectionKey InsertCuttingSection(CuttingSectionKit const & in_kit);
8169 
8171  CuttingSectionKey InsertCuttingSection(PlaneArray const & in_planes);
8172 
8174  CuttingSectionKey InsertCuttingSection(size_t in_planes_count, Plane const in_planes []);
8175 
8176 
8178  InfiniteLineKey InsertInfiniteLine(InfiniteLineKit const & in_kit);
8179 
8181  InfiniteLineKey InsertInfiniteLine(Point const & in_first, Point const & in_second, InfiniteLine::Type in_type);
8182 
8183 
8185  SpotlightKey InsertSpotlight(Point const & in_position, Point const & in_target);
8186 
8188  SpotlightKey InsertSpotlight(SpotlightKit const & in_kit);
8189 
8190 
8192  NURBSCurveKey InsertNURBSCurve(NURBSCurveKit const & in_kit);
8193 
8195  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);
8196 
8198  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);
8199 
8200 
8202  NURBSSurfaceKey InsertNURBSSurface(NURBSSurfaceKit const & in_kit);
8203 
8205  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);
8206 
8208  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[]);
8209 
8211  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);
8212 
8214  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[]);
8215 
8216 
8218  TextKey InsertText(TextKit const & in_kit);
8219 
8224  TextKey InsertText(Point const & in_position, char const * in_text);
8225 
8226 
8227 
8229  GridKey InsertGrid(GridKit const & in_kit);
8230 
8232  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);
8233 
8234 
8235 
8242  LineKey InsertLineFromGeometry(CircleKey const & in_circle, float in_deviation = -1.0f);
8243 
8251  LineKey InsertLineFromGeometry(CircularArcKey const & in_circular_arc, float in_deviation = -1.0f);
8252 
8260  LineKey InsertLineFromGeometry(CircularWedgeKey const & in_circular_wedge, float in_deviation = -1.0f);
8261 
8269  LineKey InsertLineFromGeometry(EllipseKey const & in_ellipse, float in_deviation = -1.0f);
8270 
8278  LineKey InsertLineFromGeometry(EllipticalArcKey const & in_elliptical_arc, float in_deviation = -1.0f);
8279 
8287  LineKey InsertLineFromGeometry(NURBSCurveKey const & in_nurbs_curve, float in_deviation = -1.0f);
8288 
8293  ShellKey InsertShellFromGeometry(SphereKey const & in_sphere);
8294 
8299  ShellKey InsertShellFromGeometry(CylinderKey const & in_cylinder);
8300 
8305  ShellKey InsertShellFromGeometry(NURBSSurfaceKey const & in_nurbs_surface);
8306 
8311  ShellKey InsertShellFromGeometry(MeshKey const & in_mesh);
8312 
8317  ShellKey InsertShellFromGeometry(PolygonKey const & in_polygon);
8318 
8323  ShellKey InsertShellFromGeometry(EllipseKey const & in_ellipse);
8324 
8329  ShellKey InsertShellFromGeometry(CircleKey const & in_circle);
8330 
8335  ShellKey InsertShellFromGeometry(CircularWedgeKey const & in_circular_wedge);
8336 
8341  ShellKey InsertShellFromGeometry(TextKey const & in_text);
8342 
8343 
8345  SegmentKey & SetAttributeLock(AttributeLockKit const & in_kit);
8346 
8348  SegmentKey & UnsetAttributeLock();
8349 
8353  bool ShowAttributeLock(AttributeLockKit & out_kit) const;
8354 
8356  AttributeLockControl GetAttributeLockControl();
8357 
8359  AttributeLockControl const GetAttributeLockControl() const;
8360 
8361 
8363  SegmentKey & SetBounding(BoundingKit const & in_kit);
8364 
8366  SegmentKey & UnsetBounding();
8367 
8371  bool ShowBounding(BoundingKit & out_kit) const;
8372 
8374  BoundingControl GetBoundingControl();
8375 
8377  BoundingControl const GetBoundingControl() const;
8378 
8379 
8381  SegmentKey & SetCamera(CameraKit const & in_kit);
8382 
8384  SegmentKey & UnsetCamera();
8385 
8387  bool ShowCamera(CameraKit & out_kit) const;
8388 
8390  CameraControl GetCameraControl();
8391 
8393  CameraControl const GetCameraControl() const;
8394 
8395 
8397  SegmentKey & SetColorInterpolation(ColorInterpolationKit const & in_kit);
8398 
8400  SegmentKey & UnsetColorInterpolation();
8401 
8403  bool ShowColorInterpolation(ColorInterpolationKit & out_kit) const;
8404 
8406  ColorInterpolationControl GetColorInterpolationControl();
8407 
8409  ColorInterpolationControl const GetColorInterpolationControl() const;
8410 
8411 
8413  SegmentKey & SetContourLine(ContourLineKit const & in_kit);
8414 
8416  SegmentKey & UnsetContourLine();
8417 
8419  bool ShowContourLine(ContourLineKit & out_kit) const;
8420 
8422  ContourLineControl GetContourLineControl();
8423 
8425  ContourLineControl const GetContourLineControl() const;
8426 
8427 
8429  SegmentKey & SetCulling(CullingKit const & in_kit);
8430 
8432  SegmentKey & UnsetCulling();
8433 
8437  bool ShowCulling(CullingKit & out_kit) const;
8438 
8440  CullingControl GetCullingControl();
8441 
8443  CullingControl const GetCullingControl() const;
8444 
8445 
8447  SegmentKey & SetCurveAttribute(CurveAttributeKit const & in_kit);
8448 
8450  SegmentKey & UnsetCurveAttribute();
8451 
8453  bool ShowCurveAttribute(CurveAttributeKit & out_kit) const;
8454 
8456  CurveAttributeControl GetCurveAttributeControl();
8457 
8459  CurveAttributeControl const GetCurveAttributeControl() const;
8460 
8461 
8463  SegmentKey & SetCuttingSectionAttribute(CuttingSectionAttributeKit const & in_kit);
8464 
8466  SegmentKey & UnsetCuttingSectionAttribute();
8467 
8469  bool ShowCuttingSectionAttribute(CuttingSectionAttributeKit & out_kit) const;
8470 
8472  CuttingSectionAttributeControl GetCuttingSectionAttributeControl();
8473 
8475  CuttingSectionAttributeControl const GetCuttingSectionAttributeControl() const;
8476 
8477 
8479  SegmentKey & SetCylinderAttribute(CylinderAttributeKit const & in_kit);
8480 
8482  SegmentKey & UnsetCylinderAttribute();
8483 
8485  bool ShowCylinderAttribute(CylinderAttributeKit & out_kit) const;
8486 
8488  CylinderAttributeControl GetCylinderAttributeControl();
8489 
8491  CylinderAttributeControl const GetCylinderAttributeControl() const;
8492 
8493 
8495  SegmentKey & SetDrawingAttribute(DrawingAttributeKit const & in_kit);
8496 
8498  SegmentKey & UnsetDrawingAttribute();
8499 
8501  bool ShowDrawingAttribute(DrawingAttributeKit & out_kit) const;
8502 
8504  DrawingAttributeControl GetDrawingAttributeControl();
8505 
8507  DrawingAttributeControl const GetDrawingAttributeControl() const;
8508 
8509 
8511  SegmentKey & SetEdgeAttribute(EdgeAttributeKit const & in_kit);
8512 
8514  SegmentKey & UnsetEdgeAttribute();
8515 
8517  bool ShowEdgeAttribute(EdgeAttributeKit & out_kit) const;
8518 
8520  EdgeAttributeControl GetEdgeAttributeControl();
8521 
8523  EdgeAttributeControl const GetEdgeAttributeControl() const;
8524 
8525 
8527  SegmentKey & SetHiddenLineAttribute(HiddenLineAttributeKit const & in_kit);
8528 
8530  SegmentKey & UnsetHiddenLineAttribute();
8531 
8533  bool ShowHiddenLineAttribute(HiddenLineAttributeKit & out_kit) const;
8534 
8536  HiddenLineAttributeControl GetHiddenLineAttributeControl();
8537 
8539  HiddenLineAttributeControl const GetHiddenLineAttributeControl() const;
8540 
8541 
8543  SegmentKey & SetLightingAttribute(LightingAttributeKit const & in_kit);
8544 
8546  SegmentKey & UnsetLightingAttribute();
8547 
8549  bool ShowLightingAttribute(LightingAttributeKit & out_kit) const;
8550 
8552  LightingAttributeControl GetLightingAttributeControl();
8553 
8555  LightingAttributeControl const GetLightingAttributeControl() const;
8556 
8557 
8559  SegmentKey & SetLineAttribute(LineAttributeKit const & in_kit);
8560 
8562  SegmentKey & UnsetLineAttribute();
8563 
8565  bool ShowLineAttribute(LineAttributeKit & out_kit) const;
8566 
8568  LineAttributeControl GetLineAttributeControl();
8569 
8571  LineAttributeControl const GetLineAttributeControl() const;
8572 
8573 
8575  SegmentKey & SetMaterialMapping(MaterialMappingKit const & in_kit);
8576 
8578  SegmentKey & UnsetMaterialMapping();
8579 
8581  bool ShowMaterialMapping(MaterialMappingKit & out_kit) const;
8582 
8584  SegmentKey & SetPBRMaterial(PBRMaterialKit const & in_kit);
8585 
8587  SegmentKey & UnsetPBRMaterial();
8588 
8590  bool ShowPBRMaterial(PBRMaterialKit & out_kit) const;
8591 
8593  MaterialMappingControl GetMaterialMappingControl();
8594 
8596  MaterialMappingControl const GetMaterialMappingControl() const;
8597 
8598 
8600  SegmentKey & SetMarkerAttribute(MarkerAttributeKit const & in_kit);
8601 
8603  SegmentKey & UnsetMarkerAttribute();
8604 
8606  bool ShowMarkerAttribute(MarkerAttributeKit & out_kit) const;
8607 
8609  MarkerAttributeControl GetMarkerAttributeControl();
8610 
8612  MarkerAttributeControl const GetMarkerAttributeControl() const;
8613 
8614 
8616  SegmentKey & SetModellingMatrix(MatrixKit const & in_kit);
8617 
8619  SegmentKey & UnsetModellingMatrix();
8620 
8622  bool ShowModellingMatrix(MatrixKit & out_kit) const;
8623 
8625  ModellingMatrixControl GetModellingMatrixControl();
8626 
8628  ModellingMatrixControl const GetModellingMatrixControl() const;
8629 
8630 
8632  SegmentKey & SetNURBSSurfaceAttribute(NURBSSurfaceAttributeKit const & in_kit);
8633 
8635  SegmentKey & UnsetNURBSSurfaceAttribute();
8636 
8638  bool ShowNURBSSurfaceAttribute(NURBSSurfaceAttributeKit & out_kit) const;
8639 
8641  NURBSSurfaceAttributeControl GetNURBSSurfaceAttributeControl();
8642 
8644  NURBSSurfaceAttributeControl const GetNURBSSurfaceAttributeControl() const;
8645 
8646 
8648  SegmentKey & SetPerformance(PerformanceKit const & in_kit);
8649 
8651  SegmentKey & UnsetPerformance();
8652 
8654  bool ShowPerformance(PerformanceKit & out_kit) const;
8655 
8657  PerformanceControl GetPerformanceControl();
8658 
8660  PerformanceControl const GetPerformanceControl() const;
8661 
8662 
8664  SegmentKey & SetSelectability(SelectabilityKit const & in_kit);
8665 
8667  SegmentKey & UnsetSelectability();
8668 
8672  bool ShowSelectability(SelectabilityKit & out_kit) const;
8673 
8675  SelectabilityControl GetSelectabilityControl();
8676 
8678  SelectabilityControl const GetSelectabilityControl() const;
8679 
8680 
8682  SegmentKey & SetSphereAttribute(SphereAttributeKit const & in_kit);
8683 
8685  SegmentKey & UnsetSphereAttribute();
8686 
8689  bool ShowSphereAttribute(SphereAttributeKit & out_kit) const;
8690 
8692  SphereAttributeControl GetSphereAttributeControl();
8693 
8695  SphereAttributeControl const GetSphereAttributeControl() const;
8696 
8697 
8699  SegmentKey & SetSubwindow(SubwindowKit const & in_kit);
8700 
8702  SegmentKey & UnsetSubwindow();
8703 
8706  bool ShowSubwindow(SubwindowKit & out_kit) const;
8707 
8709  SubwindowControl GetSubwindowControl();
8710 
8712  SubwindowControl const GetSubwindowControl() const;
8713 
8714 
8716  SegmentKey & SetTextAttribute(TextAttributeKit const & in_kit);
8717 
8719  SegmentKey & UnsetTextAttribute();
8720 
8722  bool ShowTextAttribute(TextAttributeKit & out_kit) const;
8723 
8725  TextAttributeControl GetTextAttributeControl();
8726 
8728  TextAttributeControl const GetTextAttributeControl() const;
8729 
8730 
8732  SegmentKey & SetTextureMatrix(MatrixKit const & in_kit);
8733 
8735  SegmentKey & UnsetTextureMatrix();
8736 
8739  bool ShowTextureMatrix(MatrixKit & out_kit) const;
8740 
8742  TextureMatrixControl GetTextureMatrixControl();
8743 
8745  TextureMatrixControl const GetTextureMatrixControl() const;
8746 
8747 
8749  SegmentKey & SetTransformMask(TransformMaskKit const & in_kit);
8750 
8752  SegmentKey & UnsetTransformMask();
8753 
8756  bool ShowTransformMask(TransformMaskKit & out_kit) const;
8757 
8759  TransformMaskControl GetTransformMaskControl();
8760 
8762  TransformMaskControl const GetTransformMaskControl() const;
8763 
8764 
8766  SegmentKey & SetTransparency(TransparencyKit const & in_kit);
8767 
8769  SegmentKey & UnsetTransparency();
8770 
8773  bool ShowTransparency(TransparencyKit & out_kit) const;
8774 
8776  TransparencyControl GetTransparencyControl();
8777 
8779  TransparencyControl const GetTransparencyControl() const;
8780 
8781 
8783  SegmentKey & SetVisibility(VisibilityKit const & in_kit);
8784 
8786  SegmentKey & UnsetVisibility();
8787 
8790  bool ShowVisibility(VisibilityKit & out_kit) const;
8791 
8793  VisibilityControl GetVisibilityControl();
8794 
8796  VisibilityControl const GetVisibilityControl() const;
8797 
8798 
8800  SegmentKey & SetVisualEffects(VisualEffectsKit const & in_kit);
8801 
8803  SegmentKey & UnsetVisualEffects();
8804 
8808  bool ShowVisualEffects(VisualEffectsKit & out_kit) const;
8809 
8811  VisualEffectsControl GetVisualEffectsControl();
8812 
8814  VisualEffectsControl const GetVisualEffectsControl() const;
8815 
8818  void Optimize(SegmentOptimizationOptionsKit const & in_kit);
8819 
8820 
8826  OptimizeMappingResults OptimizeWithMapping(SegmentOptimizationOptionsKit const & in_kit);
8827 };
8828 
8829 
8831 class HPS_API SegmentOptimizationOptionsKit : public Kit
8832 {
8833 public:
8834 
8837 
8841 
8845 
8846  virtual ~SegmentOptimizationOptionsKit();
8847 
8848  static const HPS::Type staticType = HPS::Type::SegmentOptimizationOptionsKit;
8849  HPS::Type ObjectType() const { return staticType; }
8850 
8853  void Consume(SegmentOptimizationOptionsKit & in_kit);
8854 
8857  void Set(SegmentOptimizationOptionsKit const & in_kit);
8858 
8861  void Show(SegmentOptimizationOptionsKit & out_kit) const;
8862 
8867 
8872 
8875  bool Empty() const;
8876 
8880  bool Equals(SegmentOptimizationOptionsKit const & in_kit) const;
8881 
8885  bool operator==(SegmentOptimizationOptionsKit const & in_kit) const;
8886 
8890  bool operator!=(SegmentOptimizationOptionsKit const & in_kit) const;
8891 
8895  SegmentOptimizationOptionsKit & SetUserData(HPS::SegmentOptimizationOptions::UserData in_user_data);
8896 
8900  SegmentOptimizationOptionsKit & SetMatrix(HPS::SegmentOptimizationOptions::Matrix in_matrix);
8901 
8905  SegmentOptimizationOptionsKit & SetExpansion(HPS::SegmentOptimizationOptions::Expansion in_expansion);
8906 
8910  SegmentOptimizationOptionsKit & SetScope(HPS::SegmentOptimizationOptions::Scope in_scope);
8911 
8915  SegmentOptimizationOptionsKit & SetReorganization(HPS::SegmentOptimizationOptions::Reorganization in_reorganization);
8916 
8920  SegmentOptimizationOptionsKit & SetShellInstancing(bool in_shell_instancing);
8921 
8925  SegmentOptimizationOptionsKit & SetShellMerging(bool in_shell_merging);
8926 
8930  SegmentOptimizationOptionsKit & SetAttributeDelocalization(bool in_attribute_delocalization);
8931 
8934  SegmentOptimizationOptionsKit & UnsetUserData();
8935 
8938  SegmentOptimizationOptionsKit & UnsetMatrix();
8939 
8942  SegmentOptimizationOptionsKit & UnsetExpansion();
8943 
8946  SegmentOptimizationOptionsKit & UnsetScope();
8947 
8950  SegmentOptimizationOptionsKit & UnsetReorganization();
8951 
8954  SegmentOptimizationOptionsKit & UnsetShellInstancing();
8955 
8958  SegmentOptimizationOptionsKit & UnsetShellMerging();
8959 
8962  SegmentOptimizationOptionsKit & UnsetAttributeDelocalization();
8963 
8966  SegmentOptimizationOptionsKit & UnsetEverything();
8967 
8971  bool ShowUserData(HPS::SegmentOptimizationOptions::UserData & out_user_data) const;
8972 
8976  bool ShowMatrix(HPS::SegmentOptimizationOptions::Matrix & out_matrix) const;
8977 
8981  bool ShowExpansion(HPS::SegmentOptimizationOptions::Expansion & out_expansion) const;
8982 
8986  bool ShowScope(HPS::SegmentOptimizationOptions::Scope & out_scope) const;
8987 
8991  bool ShowReorganization(HPS::SegmentOptimizationOptions::Reorganization & out_reorganization) const;
8992 
8996  bool ShowShellInstancing(bool & out_shell_instancing) const;
8997 
9001  bool ShowShellMerging(bool & out_shell_merging) const;
9002 
9006  bool ShowAttributeDelocalization(bool & out_attribute_delocalization) const;
9007 };
9008 
9009 
9012 class HPS_API UpdateNotifier : public Object
9013 {
9014 public:
9015 
9016  UpdateNotifier();
9017 
9018  UpdateNotifier(UpdateNotifier const & in_that);
9019 
9023  UpdateNotifier(UpdateNotifier && in_that);
9024 
9028  UpdateNotifier & operator=(UpdateNotifier && in_that);
9029 
9030  virtual ~UpdateNotifier();
9031 
9032  static const HPS::Type staticType = HPS::Type::UpdateNotifier;
9033  HPS::Type ObjectType() const {return staticType;};
9034 
9038  UpdateNotifier & operator=(UpdateNotifier const & in_that);
9039 
9042  void Assign(UpdateNotifier const & in_that);
9043 
9046  UpdateNotifier const & Wait() const;
9047 
9051  UpdateNotifier const & Cancel() const;
9052 
9054  Window::UpdateStatus Status() const;
9055 
9056 };
9057 
9060 class HPS_API DriverEvent
9061 {
9062 public:
9063 
9064  virtual ~DriverEvent();
9065 
9067  intptr_t GetClassID() const;
9068 
9069  enum class StereoMatrix
9070  {
9071  ViewLeft,
9072  ViewRight,
9073  ProjectionLeft,
9074  ProjectionRight,
9075  };
9076 
9077  void SetStereoMatrix(StereoMatrix id, HPS::MatrixKit const & in_matrix) const;
9078  OpaqueHandle GetSurface(int index) const;
9079  OpaqueHandle GetGraphicsContext() const;
9080 
9081 protected:
9082 
9083  DriverEvent(OpaqueHandle in_nr) : nr(in_nr)
9084  {
9085 
9086  }
9087 
9088  OpaqueHandle nr;
9089 };
9090 
9093 class HPS_API FinishPictureEvent : public DriverEvent
9094 {
9095 public:
9096  FinishPictureEvent(OpaqueHandle in_nr = 0);
9097  virtual ~FinishPictureEvent();
9098 };
9099 
9100 class HPS_API InitPictureEvent : public DriverEvent
9101 {
9102 public:
9103  InitPictureEvent(OpaqueHandle in_nr = 0);
9104  virtual ~InitPictureEvent();
9105 
9106  void SetRenderSurface(OpaqueHandle target) const;
9107 };
9108 
9110 class HPS_API DrawWindowEvent : public DriverEvent
9111 {
9112 public:
9113  DrawWindowEvent(OpaqueHandle in_nr = 0);
9114  virtual ~DrawWindowEvent();
9115 
9118 
9122  {
9123  RGBA,
9124  BGRA,
9125  ImageExternal,
9126  LumaChromaPair
9127  };
9128 
9134  void DrawTexturedBackground(OpaqueHandle in_texture, BackgroundTextureFormat in_format, MatrixKit const & in_matrix, IntRectangle const & in_extent) const;
9135 
9136 private:
9137 
9138  mutable HPS::FloatArray matrix_elements;
9139 };
9140 
9142 class HPS_API DriverEventHandler : public Object
9143 {
9144 public:
9145 
9146  static const HPS::Type staticType = HPS::Type::DriverEventHandler;
9147  HPS::Type ObjectType() const override { return staticType; };
9148 
9150 
9151  DriverEventHandler(DriverEventHandler const & that);
9152 
9153  virtual ~DriverEventHandler();
9154 
9158  virtual void Handle(DriverEvent const * in_event)
9159  {
9160  HPS_UNREFERENCED(in_event);
9161  }
9162 };
9163 
9164 
9165 
9166 
9170 class HPS_API WindowKey : public SegmentKey
9171 {
9172 public:
9173 
9175  WindowKey();
9176 
9178  WindowKey(WindowKey const & in_window);
9179 
9181  WindowKey & operator=(WindowKey const & other);
9182 
9186  WindowKey(WindowKey && in_that);
9187 
9191  WindowKey & operator=(WindowKey && in_that);
9192 
9194  WindowKey(Key const & in_key);
9195 
9197  ~WindowKey();
9198 
9199  static const HPS::Type staticType = HPS::Type::WindowKey;
9200  HPS::Type ObjectType() const {return staticType;};
9201 
9203  bool ConvertCoordinate(Coordinate::Space in_space, Point const & in_point, Coordinate::Space in_output_space, Point & out_point) const;
9204 
9209  size_t FindFonts(FontSearchResults & out_results) const;
9210 
9215  size_t FindHighlights(HighlightSearchOptionsKit const & in_options, HighlightSearchResults & out_results) const;
9216 
9223  size_t FindHighlights(KeyPath const & in_key_path, HPS::HighlightSearch::Scope in_scope, HighlightSearchOptionsKit const & in_options, HighlightSearchResults & out_results) const;
9224 
9226  WindowKey & SetPostProcessEffects(PostProcessEffectsKit const & in_kit);
9227 
9229  bool ShowPostProcessEffects(PostProcessEffectsKit & out_kit) const;
9230 
9232  PostProcessEffectsControl GetPostProcessEffectsControl();
9233 
9235  PostProcessEffectsControl const GetPostProcessEffectsControl() const;
9236 
9237 
9239  WindowKey & SetDebugging(DebuggingKit const & in_kit);
9240 
9244  WindowKey & SetDriverEventHandler(DriverEventHandler const & in_handler, intptr_t in_type);
9245 
9248  WindowKey & UnsetDriverEventHandler(intptr_t in_type);
9249 
9253  bool ShowDebugging(DebuggingKit & out_kit) const;
9254 
9256  DebuggingControl GetDebuggingControl();
9257 
9259  DebuggingControl const GetDebuggingControl() const;
9260 
9262  WindowInfoControl const GetWindowInfoControl() const;
9263 
9264  bool ShowWindowInfo(WindowInfoKit & out_kit) const;
9265 
9267  WindowKey & SetSelectionOptions(SelectionOptionsKit const & in_kit);
9268 
9270  bool ShowSelectionOptions(SelectionOptionsKit & out_kit) const;
9271 
9273  WindowKey & SetUpdateOptions(HPS::UpdateOptionsKit const & in_kit);
9274 
9276  bool ShowUpdateOptions(HPS::UpdateOptionsKit & out_kit) const;
9277 
9278 
9280  SelectionOptionsControl GetSelectionOptionsControl();
9281 
9283  SelectionOptionsControl const GetSelectionOptionsControl() const;
9284 
9285 
9287  SelectionControl GetSelectionControl();
9288 
9290  SelectionControl const GetSelectionControl() const;
9291 
9293  HighlightControl GetHighlightControl();
9294 
9296  HighlightControl const GetHighlightControl() const;
9297 
9299  UpdateOptionsControl GetUpdateOptionsControl();
9300 
9302  UpdateOptionsControl const GetUpdateOptionsControl() const;
9303 
9305  void Update();
9306 
9311  void Update(UpdateOptionsKit const & in_kit);
9312 
9327  void Update(Window::UpdateType in_type, Time in_time_limit=-1);
9328 
9332  UpdateNotifier UpdateWithNotifier();
9333 
9337  UpdateNotifier UpdateWithNotifier(HPS::UpdateOptionsKit const & in_kit);
9338 
9344  UpdateNotifier UpdateWithNotifier(Window::UpdateType in_type, Time in_time_limit=-1);
9345 
9347  EventDispatcher & GetEventDispatcher();
9348 
9350  EventDispatcher const & GetEventDispatcher() const;
9351 
9355  bool ShowSnapshot(ImageKit & out_kit) const;
9356 
9357 private:
9358 
9360  SegmentKey & UnsetAttributeLock();
9361  SegmentKey & UnsetCamera();
9362  SegmentKey & UnsetColorInterpolation();
9363  SegmentKey & UnsetContourLine();
9364  SegmentKey & UnsetCulling();
9365  SegmentKey & UnsetCurveAttribute();
9366  SegmentKey & UnsetCuttingSectionAttribute();
9367  SegmentKey & UnsetCylinderAttribute();
9368  SegmentKey & UnsetDrawingAttribute();
9369  SegmentKey & UnsetEdgeAttribute();
9370  SegmentKey & UnsetHiddenLineAttribute();
9371  SegmentKey & UnsetLightingAttribute();
9372  SegmentKey & UnsetLineAttribute();
9373  SegmentKey & UnsetMaterialMapping();
9374  SegmentKey & UnsetMarkerAttribute();
9375  SegmentKey & UnsetModellingMatrix();
9376  SegmentKey & UnsetNURBSSurfaceAttribute();
9377  SegmentKey & UnsetPerformance();
9378  SegmentKey & UnsetSelectability();
9379  SegmentKey & UnsetSphereAttribute();
9380  SegmentKey & UnsetSubwindow();
9381  SegmentKey & UnsetTextAttribute();
9382  SegmentKey & UnsetTextureMatrix();
9383  SegmentKey & UnsetTransformMask();
9384  SegmentKey & UnsetTransparency();
9385  SegmentKey & UnsetVisibility();
9386  SegmentKey & UnsetVisualEffects();
9387 
9389  void MoveTo(SegmentKey const & in_new_owner);
9390 
9392  Key CopyTo(SegmentKey const & in_destination) const;
9393 };
9394 
9395 
9396 
9399 class HPS_API KeyPath : public Object
9400 {
9401 public:
9402 
9404  KeyPath();
9405 
9408  KeyPath(KeyArray const & in_path);
9409 
9413  KeyPath(size_t in_path_count, Key const in_path []);
9414 
9416  KeyPath(KeyPath const & in_that);
9417 
9421  KeyPath(KeyPath && in_that);
9422 
9426  KeyPath & operator=(KeyPath && in_that);
9427 
9429  virtual ~KeyPath();
9430 
9431  static const HPS::Type staticType = HPS::Type::KeyPath;
9432  HPS::Type ObjectType() const { return staticType; }
9433 
9437  KeyPath & operator+=(Key const & in_key);
9438 
9442  KeyPath & operator+=(KeyPath const & in_key_path);
9443 
9447  KeyPath & operator+=(KeyArray const & in_key_array);
9448 
9453  KeyPath & Append(Key const & in_key);
9454 
9459  KeyPath & Append(KeyPath const & in_key_path);
9460 
9465  KeyPath & Append(KeyArray const & in_key_array);
9466 
9470  KeyPath & operator=(KeyPath const & in_that);
9471 
9475  KeyPath & operator=(KeyArray const & in_path);
9476 
9479  void Set(KeyPath const & in_that);
9480 
9484  bool Equals(KeyPath const & in_that) const;
9485 
9489  bool operator!= (KeyPath const & in_that) const;
9490 
9494  bool operator== (KeyPath const & in_that) const;
9495 
9496 
9500  KeyPath & SetKeys(KeyArray const & in_keys);
9501 
9506  KeyPath & SetKeys(size_t in_key_count, Key const in_keys []);
9507 
9508 
9511  KeyPath & UnsetKeys();
9512 
9513 
9516  bool ShowKeys(KeyArray & out_keys) const;
9517 
9518 
9525  bool ConvertCoordinate(Coordinate::Space in_space, Point const & in_point, Coordinate::Space in_output_space, Point & out_point) const;
9526 
9533  bool ConvertCoordinate(Coordinate::Space in_space, PointArray const & in_points, Coordinate::Space in_output_space, PointArray & out_points) const;
9534 
9542  bool ComputeTextExtent(char const * in_text, float & out_xfrac, float & out_yfrac) const;
9543 
9549  bool ComputeExtent(Rectangle & out_extent) const;
9550 
9557  bool ComputeExtent(HPS::VisibilityKit const & in_vis, Rectangle & out_extent) const;
9558 
9559 
9566  bool ComputeExtent(HPS::Extent::ClipRegion in_clip, Rectangle & out_extent) const;
9567 
9568 
9576  bool ComputeExtent(HPS::VisibilityKit const & in_vis, HPS::Extent::ClipRegion in_clip, Rectangle & out_extent) const;
9577 
9583  bool ComputeTransform(Coordinate::Space in_space, Coordinate::Space in_output_space, HPS::MatrixKit & out_matrix) const;
9584 
9587  bool ShowNetVisibility(VisibilityKit & out_kit) const;
9588 
9591  bool ShowNetBounding(BoundingKit & out_kit) const;
9592 
9595  bool ShowNetCamera(CameraKit & out_kit) const;
9596 
9599  bool ShowNetColorInterpolation(ColorInterpolationKit & out_kit) const;
9600 
9603  bool ShowNetContourLine(ContourLineKit & out_kit) const;
9604 
9607  bool ShowNetPerformance(PerformanceKit & out_kit) const;
9608 
9611  bool ShowNetHiddenLineAttribute(HiddenLineAttributeKit & out_kit) const;
9612 
9615  bool ShowNetDrawingAttribute(DrawingAttributeKit & out_kit) const;
9616 
9619  bool ShowNetSelectability(SelectabilityKit & out_kit) const;
9620 
9623  bool ShowNetMarkerAttribute(MarkerAttributeKit & out_kit) const;
9624 
9627  bool ShowNetSphereAttribute(SphereAttributeKit & out_kit) const;
9628 
9631  bool ShowNetLightingAttribute(LightingAttributeKit & out_kit) const;
9632 
9635  bool ShowNetCylinderAttribute(CylinderAttributeKit & out_kit) const;
9636 
9639  bool ShowNetCuttingSectionAttribute(CuttingSectionAttributeKit & out_kit) const;
9640 
9643  bool ShowNetTextAttribute(TextAttributeKit & out_kit) const;
9644 
9647  bool ShowNetLineAttribute(LineAttributeKit & out_kit) const;
9648 
9651  bool ShowNetEdgeAttribute(EdgeAttributeKit & out_kit) const;
9652 
9655  bool ShowNetCurveAttribute(CurveAttributeKit & out_kit) const;
9656 
9659  bool ShowNetModellingMatrix(MatrixKit & out_kit) const;
9660 
9663  bool ShowNetTextureMatrix(MatrixKit & out_kit) const;
9664 
9667  bool ShowNetCulling(CullingKit & out_kit) const;
9668 
9671  bool ShowNetTransparency(TransparencyKit & out_kit) const;
9672 
9675  bool ShowNetTransformMask(TransformMaskKit & out_kit) const;
9676 
9679  bool ShowNetMaterialMapping(MaterialMappingKit & out_kit) const;
9680 
9683  bool ShowNetPBRMaterial(PBRMaterialKit & out_kit) const;
9684 
9687  bool ShowNetNURBSSurfaceAttribute(NURBSSurfaceAttributeKit & out_kit) const;
9688 
9691  bool ShowNetVisualEffects(VisualEffectsKit & out_kit) const;
9692 
9695  bool ShowNetSubwindow(SubwindowKit & out_kit) const;
9696 
9699  bool ShowNetAttributeLock(AttributeLockKit & out_kit) const;
9700 
9703  bool ShowNetConditions(UTF8Array & out_conditions) const;
9704 
9710  size_t GatherCutGeometry(SegmentKey const & in_destination, CutGeometryGatheringOptionsKit const & in_options) const;
9711 
9712 
9719  bool ShowNetClipRegions(PointArrayArrayArray & out_loops_array, ClipSpaceArray & out_spaces, ClipOperationArray & out_operations, MatrixKitArray & out_matrices) const;
9720 
9723  bool ShowNetMaterialPalette(UTF8 & out_name) const;
9724 
9729  bool ShowEffectiveMaterialPaletteDefinition(char const * in_name, MaterialPaletteDefinition & out_def) const;
9730 
9735  bool ShowEffectiveGlyphDefinition(char const * in_name, GlyphDefinition & out_def) const;
9736 
9741  bool ShowEffectiveLinePatternDefinition(char const * in_name, LinePatternDefinition & out_def) const;
9742 
9747  bool ShowEffectiveShaderDefinition(char const * in_name, ShaderDefinition & out_def) const;
9748 
9753  bool ShowEffectiveTextureDefinition(char const * in_name, TextureDefinition & out_def) const;
9754 
9759  bool ShowEffectiveImageDefinition(char const * in_name, ImageDefinition & out_def) const;
9760 
9763  size_t Size() const;
9764 
9767  virtual bool Empty() const;
9768 
9772  Key & At(size_t in_index);
9773 
9777  Key const & At(size_t in_index) const;
9778 
9783  void Insert(size_t in_index, Key const & in_item);
9784 
9788  void Remove(Key const & in_item);
9789 
9792  void Remove(size_t in_index);
9793 
9796  KeyPath Reverse() const;
9797 
9800  Key & Front();
9801 
9804  Key const & Front() const;
9805 
9808  Key & Back();
9809 
9812  Key const & Back() const;
9813 
9816  Key PopFront();
9817 
9820  Key PopBack();
9821 
9825  KeyPath & PushFront(Key const & in_key);
9826 
9830  KeyPath & PushBack(Key const & in_key);
9831 
9835  KeyPath & PushBack(KeyPath const & in_key_path);
9836 
9840  KeyPath & PushBack(KeyArray const & in_key_array);
9841 
9842 #ifndef HPS_GULP_CLANG
9843  using iterator = HPS::KeyArray::iterator;
9844  using const_iterator = HPS::KeyArray::const_iterator;
9845 
9848  iterator begin();
9849 
9852  const_iterator begin() const;
9853 
9856  iterator end();
9857 
9860  const_iterator end() const;
9861 
9864  const_iterator cbegin() const;
9865 
9868  const_iterator cend() const;
9869 #endif
9870 };
9871 
9876 inline KeyPath operator+(Key const & in_lhs, Key const & in_rhs)
9877 {
9878  return HPS::KeyPath().PushBack(in_lhs).PushBack(in_rhs);
9879 }
9880 
9885 inline KeyPath operator+(Key const & in_lhs, KeyArray const & in_rhs)
9886 {
9887  return HPS::KeyPath().PushBack(in_lhs).PushBack(in_rhs);
9888 }
9889 
9894 inline KeyPath operator+(Key const & in_lhs, KeyPath const & in_rhs)
9895 {
9896  return HPS::KeyPath().PushBack(in_lhs).PushBack(in_rhs);
9897 }
9898 
9903 inline KeyPath operator+(KeyArray const & in_lhs, Key const & in_rhs)
9904 {
9905  return HPS::KeyPath().PushBack(in_lhs).PushBack(in_rhs);
9906 }
9907 
9912 inline KeyPath operator+(KeyArray const & in_lhs, KeyArray const & in_rhs)
9913 {
9914  return HPS::KeyPath().PushBack(in_lhs).PushBack(in_rhs);
9915 }
9916 
9921 inline KeyPath operator+(KeyArray const & in_lhs, KeyPath const & in_rhs)
9922 {
9923  return HPS::KeyPath().PushBack(in_lhs).PushBack(in_rhs);
9924 }
9925 
9930 inline KeyPath operator+(KeyPath const & in_lhs, Key const & in_rhs)
9931 {
9932  return HPS::KeyPath().PushBack(in_lhs).PushBack(in_rhs);
9933 }
9934 
9939 inline KeyPath operator+(KeyPath const & in_lhs, KeyArray const & in_rhs)
9940 {
9941  return HPS::KeyPath().PushBack(in_lhs).PushBack(in_rhs);
9942 }
9943 
9948 inline KeyPath operator+(KeyPath const & in_lhs, KeyPath const & in_rhs)
9949 {
9950  return HPS::KeyPath().PushBack(in_lhs).PushBack(in_rhs);
9951 }
9952 
9953 
9957 
9959 class HPS_API BoundingKit : public Kit
9960 {
9961 public:
9962 
9964  BoundingKit();
9965 
9968  BoundingKit(BoundingKit const & in_kit);
9969 
9973  BoundingKit(BoundingKit && in_that);
9974 
9978  BoundingKit & operator=(BoundingKit && in_that);
9979 
9981  virtual ~BoundingKit();
9982 
9983  static const HPS::Type staticType = HPS::Type::BoundingKit;
9984  HPS::Type ObjectType() const {return staticType;};
9985 
9989  static BoundingKit GetDefault();
9990 
9993  void Set(BoundingKit const & in_kit);
9994 
9997  void Show(BoundingKit & out_kit) const;
9998 
10002  BoundingKit & operator=(BoundingKit const & in_kit);
10003 
10006  bool Empty() const;
10007 
10011  bool Equals(BoundingKit const & in_kit) const;
10012 
10016  bool operator==(BoundingKit const & in_kit) const;
10017 
10021  bool operator!=(BoundingKit const & in_kit) const;
10022 
10023 
10027  BoundingKit & SetVolume(SimpleSphere const & in_sphere);
10028 
10032  BoundingKit & SetVolume(SimpleCuboid const & in_cuboid);
10033 
10037  BoundingKit & SetExclusion(bool in_exclude);
10038 
10039 
10042  BoundingKit & UnsetVolume();
10043 
10046  BoundingKit & UnsetExclusion();
10047 
10050  BoundingKit & UnsetEverything();
10051 
10052 
10057  bool ShowVolume(SimpleSphere & out_sphere, SimpleCuboid & out_cuboid) const;
10058 
10062  bool ShowExclusion(bool & out_exclusion) const;
10063 
10064 };
10065 
10066 
10069 class HPS_API BoundingControl : public Control
10070 {
10071 public:
10072 
10074  explicit BoundingControl(SegmentKey & in_seg);
10075 
10077  BoundingControl(BoundingControl const & in_that);
10078 
10082  BoundingControl(BoundingControl && in_that);
10083 
10087  BoundingControl & operator=(BoundingControl && in_that);
10088 
10090  ~BoundingControl();
10091 
10092  virtual HPS::Type Type() const { return ObjectType(); }
10093 
10094  static const HPS::Type staticType = HPS::Type::BoundingControl;
10095  HPS::Type ObjectType() const {return staticType;};
10096 
10100  BoundingControl & operator=(BoundingControl const & in_that);
10101 
10106  BoundingControl & SetVolume(SimpleSphere const & in_sphere, SimpleCuboid const & in_cuboid);
10107 
10111  BoundingControl & SetVolume(SimpleSphere const & in_sphere);
10112 
10116  BoundingControl & SetVolume(SimpleCuboid const & in_cuboid);
10117 
10121  BoundingControl & SetExclusion(bool in_exclusion);
10122 
10123 
10127  BoundingControl & UnsetVolume();
10128 
10132  BoundingControl & UnsetExclusion();
10133 
10137  BoundingControl & UnsetEverything();
10138 
10139 
10144  bool ShowVolume(SimpleSphere & out_sphere, SimpleCuboid & out_cuboid) const;
10145 
10149  bool ShowExclusion(bool & out_exclusion) const;
10150 
10151 private:
10153  BoundingControl();
10154 };
10155 
10156 
10158 class HPS_API VisibilityKit : public Kit
10159 {
10160 public:
10161 
10163  VisibilityKit();
10164 
10167  VisibilityKit(VisibilityKit const & in_kit);
10168 
10172  VisibilityKit(VisibilityKit && in_that);
10173 
10177  VisibilityKit & operator=(VisibilityKit && in_that);
10178 
10180  virtual ~VisibilityKit();
10181 
10182  static const HPS::Type staticType = HPS::Type::VisibilityKit;
10183  HPS::Type ObjectType() const {return staticType;};
10184 
10188  static VisibilityKit GetDefault();
10189 
10192  void Set(VisibilityKit const & in_kit);
10193 
10196  void Show(VisibilityKit & out_kit) const;
10197 
10201  VisibilityKit & operator=(VisibilityKit const & in_kit);
10202 
10205  bool Empty() const;
10206 
10210  bool Equals(VisibilityKit const & in_kit) const;
10211 
10215  bool operator==(VisibilityKit const & in_kit) const;
10216 
10220  bool operator!=(VisibilityKit const & in_kit) const;
10221 
10222 
10226  VisibilityKit & SetCuttingSections(bool in_state);
10227 
10231  VisibilityKit & SetCutEdges(bool in_state);
10232 
10236  VisibilityKit & SetCutFaces(bool in_state);
10237 
10241  VisibilityKit & SetWindows(bool in_state);
10242 
10246  VisibilityKit & SetText(bool in_state);
10247 
10251  VisibilityKit & SetLines(bool in_state);
10252 
10256  VisibilityKit & SetEdgeLights(bool in_state);
10257 
10261  VisibilityKit & SetMarkerLights(bool in_state);
10262 
10266  VisibilityKit & SetFaceLights(bool in_state);
10267 
10271  VisibilityKit & SetGenericEdges(bool in_state);
10272 
10276  VisibilityKit & SetInteriorSilhouetteEdges(bool in_state);
10277 
10284  VisibilityKit & SetAdjacentEdges(bool in_state);
10285 
10289  VisibilityKit & SetHardEdges(bool in_state);
10290 
10294  VisibilityKit & SetMeshQuadEdges(bool in_state);
10295 
10299  VisibilityKit & SetNonCulledEdges(bool in_state);
10300 
10304  VisibilityKit & SetPerimeterEdges(bool in_state);
10305 
10309  VisibilityKit & SetFaces(bool in_state);
10310 
10314  VisibilityKit & SetVertices(bool in_state);
10315 
10319  VisibilityKit & SetMarkers(bool in_state);
10320 
10324  VisibilityKit & SetShadowCasting(bool in_state);
10325 
10329  VisibilityKit & SetShadowReceiving(bool in_state);
10330 
10334  VisibilityKit & SetShadowEmitting(bool in_state);
10335 
10336 
10340  VisibilityKit & SetCutGeometry(bool in_state);
10341 
10345  VisibilityKit & SetEdges(bool in_state);
10346 
10350  VisibilityKit & SetGeometry(bool in_state);
10351 
10355  VisibilityKit & SetLights(bool in_state);
10356 
10360  VisibilityKit & SetShadows(bool in_state);
10361 
10365  VisibilityKit & SetLeaderLines(bool in_state);
10366 
10370  VisibilityKit & SetEverything(bool in_state);
10371 
10372 
10375  VisibilityKit & UnsetCuttingSections();
10376 
10379  VisibilityKit & UnsetCutEdges();
10380 
10383  VisibilityKit & UnsetCutFaces();
10384 
10387  VisibilityKit & UnsetWindows();
10388 
10391  VisibilityKit & UnsetText();
10392 
10395  VisibilityKit & UnsetLines();
10396 
10399  VisibilityKit & UnsetEdgeLights();
10400 
10403  VisibilityKit & UnsetMarkerLights();
10404 
10407  VisibilityKit & UnsetFaceLights();
10408 
10411  VisibilityKit & UnsetGenericEdges();
10412 
10415  VisibilityKit & UnsetInteriorSilhouetteEdges();
10416 
10419  VisibilityKit & UnsetAdjacentEdges();
10420 
10423  VisibilityKit & UnsetHardEdges();
10424 
10427  VisibilityKit & UnsetMeshQuadEdges();
10428 
10431  VisibilityKit & UnsetNonCulledEdges();
10432 
10435  VisibilityKit & UnsetPerimeterEdges();
10436 
10439  VisibilityKit & UnsetFaces();
10440 
10443  VisibilityKit & UnsetVertices();
10444 
10447  VisibilityKit & UnsetMarkers();
10448 
10451  VisibilityKit & UnsetShadowCasting();
10452 
10455  VisibilityKit & UnsetShadowReceiving();
10456 
10459  VisibilityKit & UnsetShadowEmitting();
10460 
10461 
10464  VisibilityKit & UnsetCutGeometry();
10465 
10468  VisibilityKit & UnsetEdges();
10469 
10472  VisibilityKit & UnsetGeometry();
10473 
10476  VisibilityKit & UnsetLights();
10477 
10480  VisibilityKit & UnsetShadows();
10481 
10484  VisibilityKit & UnsetLeaderLines();
10485 
10488  VisibilityKit & UnsetEverything();
10489 
10490 
10494  bool ShowCuttingSections(bool & out_state) const;
10495 
10499  bool ShowCutEdges(bool & out_state) const;
10500 
10504  bool ShowCutFaces(bool & out_state) const;
10505 
10509  bool ShowWindows(bool & out_state) const;
10510 
10514  bool ShowText(bool & out_state) const;
10515 
10519  bool ShowLines(bool & out_state) const;
10520 
10524  bool ShowEdgeLights(bool & out_state) const;
10525 
10529  bool ShowMarkerLights(bool & out_state) const;
10530 
10534  bool ShowFaceLights(bool & out_state) const;
10535 
10539  bool ShowGenericEdges(bool & out_state) const;
10540 
10544  bool ShowInteriorSilhouetteEdges(bool & out_state) const;
10545 
10549  bool ShowAdjacentEdges(bool & out_state) const;
10550 
10554  bool ShowHardEdges(bool & out_state) const;
10555 
10559  bool ShowMeshQuadEdges(bool & out_state) const;
10560 
10564  bool ShowNonCulledEdges(bool & out_state) const;
10565 
10569  bool ShowPerimeterEdges(bool & out_state) const;
10570 
10574  bool ShowFaces(bool & out_state) const;
10575 
10579  bool ShowVertices(bool & out_state) const;
10580 
10584  bool ShowMarkers(bool & out_state) const;
10585 
10589  bool ShowShadowCasting(bool & out_state) const;
10590 
10594  bool ShowShadowReceiving(bool & out_state) const;
10595 
10599  bool ShowShadowEmitting(bool & out_state) const;
10600 
10604  bool ShowLeaderLines(bool & out_state) const;
10605 };
10606 
10607 
10613 class HPS_API VisibilityControl : public Control
10614 {
10615 public:
10616 
10618  explicit VisibilityControl(SegmentKey & in_seg);
10619 
10621  VisibilityControl(VisibilityControl const & in_that);
10622 
10627 
10631  VisibilityControl & operator=(VisibilityControl && in_that);
10632 
10634  ~VisibilityControl();
10635 
10636  virtual HPS::Type Type() const { return ObjectType(); }
10637 
10638  static const HPS::Type staticType = HPS::Type::VisibilityControl;
10639  HPS::Type ObjectType() const {return staticType;};
10640 
10644  VisibilityControl & operator=(VisibilityControl const & in_that);
10645 
10649  VisibilityControl & SetCuttingSections(bool in_state);
10650 
10654  VisibilityControl & SetCutEdges(bool in_state);
10655 
10659  VisibilityControl & SetCutFaces(bool in_state);
10660 
10664  VisibilityControl & SetWindows(bool in_state);
10665 
10669  VisibilityControl & SetText(bool in_state);
10670 
10674  VisibilityControl & SetLines(bool in_state);
10675 
10679  VisibilityControl & SetEdgeLights(bool in_state);
10680 
10684  VisibilityControl & SetMarkerLights(bool in_state);
10685 
10689  VisibilityControl & SetFaceLights(bool in_state);
10690 
10694  VisibilityControl & SetGenericEdges(bool in_state);
10695 
10699  VisibilityControl & SetInteriorSilhouetteEdges(bool in_state);
10700 
10704  VisibilityControl & SetAdjacentEdges(bool in_state);
10705 
10709  VisibilityControl & SetHardEdges(bool in_state);
10710 
10714  VisibilityControl & SetMeshQuadEdges(bool in_state);
10715 
10719  VisibilityControl & SetNonCulledEdges(bool in_state);
10720 
10724  VisibilityControl & SetPerimeterEdges(bool in_state);
10725 
10729  VisibilityControl & SetFaces(bool in_state);
10730 
10734  VisibilityControl & SetVertices(bool in_state);
10735 
10739  VisibilityControl & SetMarkers(bool in_state);
10740 
10744  VisibilityControl & SetShadowCasting(bool in_state);
10745 
10749  VisibilityControl & SetShadowReceiving(bool in_state);
10750 
10754  VisibilityControl & SetShadowEmitting(bool in_state);
10755 
10756 
10760  VisibilityControl & SetCutGeometry(bool in_state);
10761 
10765  VisibilityControl & SetEdges(bool in_state);
10766 
10770  VisibilityControl & SetGeometry(bool in_state);
10771 
10775  VisibilityControl & SetLights(bool in_state);
10776 
10780  VisibilityControl & SetShadows(bool in_state);
10781 
10785  VisibilityControl & SetLeaderLines(bool in_state);
10786 
10790  VisibilityControl & SetEverything(bool in_state);
10791 
10792 
10796  VisibilityControl & UnsetCuttingSections();
10797 
10801  VisibilityControl & UnsetCutEdges();
10802 
10806  VisibilityControl & UnsetCutFaces();
10807 
10811  VisibilityControl & UnsetWindows();
10812 
10816  VisibilityControl & UnsetText();
10817 
10821  VisibilityControl & UnsetLines();
10822 
10826  VisibilityControl & UnsetEdgeLights();
10827 
10831  VisibilityControl & UnsetMarkerLights();
10832 
10836  VisibilityControl & UnsetFaceLights();
10837 
10841  VisibilityControl & UnsetGenericEdges();
10842 
10846  VisibilityControl & UnsetInteriorSilhouetteEdges();
10847 
10851  VisibilityControl & UnsetAdjacentEdges();
10852 
10856  VisibilityControl & UnsetHardEdges();
10857 
10861  VisibilityControl & UnsetMeshQuadEdges();
10862 
10866  VisibilityControl & UnsetNonCulledEdges();
10867 
10871  VisibilityControl & UnsetPerimeterEdges();
10872 
10876  VisibilityControl & UnsetFaces();
10877 
10881  VisibilityControl & UnsetVertices();
10882 
10886  VisibilityControl & UnsetMarkers();
10887 
10891  VisibilityControl & UnsetShadowCasting();
10892 
10896  VisibilityControl & UnsetShadowReceiving();
10897 
10901  VisibilityControl & UnsetShadowEmitting();
10902 
10903 
10907  VisibilityControl & UnsetCutGeometry();
10908 
10912  VisibilityControl & UnsetEdges();
10913 
10917  VisibilityControl & UnsetGeometry();
10918 
10922  VisibilityControl & UnsetLights();
10923 
10927  VisibilityControl & UnsetShadows();
10928 
10932  VisibilityControl & UnsetLeaderLines();
10933 
10937  VisibilityControl & UnsetEverything();
10938 
10939 
10943  bool ShowCuttingSections(bool & out_state) const;
10944 
10948  bool ShowCutEdges(bool & out_state) const;
10949 
10953  bool ShowCutFaces(bool & out_state) const;
10954 
10958  bool ShowWindows(bool & out_state) const;
10959 
10963  bool ShowText(bool & out_state) const;
10964 
10968  bool ShowLines(bool & out_state) const;
10969 
10973  bool ShowEdgeLights(bool & out_state) const;
10974 
10978  bool ShowMarkerLights(bool & out_state) const;
10979 
10983  bool ShowFaceLights(bool & out_state) const;
10984 
10988  bool ShowGenericEdges(bool & out_state) const;
10989 
10993  bool ShowInteriorSilhouetteEdges(bool & out_state) const;
10994 
10998  bool ShowAdjacentEdges(bool & out_state) const;
10999 
11003  bool ShowHardEdges(bool & out_state) const;
11004 
11008  bool ShowMeshQuadEdges(bool & out_state) const;
11009 
11013  bool ShowNonCulledEdges(bool & out_state) const;
11014 
11018  bool ShowPerimeterEdges(bool & out_state) const;
11019 
11023  bool ShowFaces(bool & out_state) const;
11024 
11028  bool ShowVertices(bool & out_state) const;
11029 
11033  bool ShowMarkers(bool & out_state) const;
11034 
11038  bool ShowShadowCasting(bool & out_state) const;
11039 
11043  bool ShowShadowReceiving(bool & out_state) const;
11044 
11048  bool ShowShadowEmitting(bool & out_state) const;
11049 
11053  bool ShowLeaderLines(bool & out_state) const;
11054 
11055 private:
11058 };
11059 
11060 
11061 
11064 class HPS_API CameraKit : public Kit
11065 {
11066 public:
11067 
11069  CameraKit();
11070 
11073  CameraKit(const CameraKit & in_kit);
11074 
11078  CameraKit(CameraKit && in_that);
11079 
11083  CameraKit & operator=(CameraKit && in_that);
11084 
11086  virtual ~CameraKit();
11087 
11088  static const HPS::Type staticType = HPS::Type::CameraKit;
11089  HPS::Type ObjectType() const {return staticType;};
11090 
11094  static CameraKit GetDefault();
11095 
11098  void Set(CameraKit const & in_kit);
11099 
11102  void Show(CameraKit & out_kit) const;
11103 
11107  CameraKit & operator=(CameraKit const & in_kit);
11108 
11111  bool Empty() const;
11112 
11116  bool Equals(CameraKit const & in_kit) const;
11117 
11121  bool operator==(CameraKit const & in_kit) const;
11122 
11126  bool operator!=(CameraKit const & in_kit) const;
11127 
11131  CameraKit & SetUpVector(Vector const & in_up);
11132 
11136  CameraKit & SetPosition(Point const & in_position);
11137 
11141  CameraKit & SetTarget(Point const & in_target);
11142 
11149  CameraKit & SetProjection(Camera::Projection in_type, float in_oblique_y_skew = 0.0f, float in_oblique_x_skew = 0.0f);
11150 
11156  CameraKit & SetField(float in_width, float in_height);
11157 
11167  CameraKit & SetNearLimit(float const in_limit);
11168 
11171  CameraKit & UnsetUpVector();
11172 
11175  CameraKit & UnsetPosition();
11176 
11179  CameraKit & UnsetTarget();
11180 
11183  CameraKit & UnsetProjection();
11184 
11187  CameraKit & UnsetField();
11188 
11191  CameraKit & UnsetNearLimit();
11192 
11195  CameraKit & UnsetEverything();
11196 
11197 
11201  bool ShowUpVector(Vector & out_up_vector) const;
11202 
11206  bool ShowPosition(Point & out_position) const;
11207 
11211  bool ShowTarget(Point & out_target) const;
11212 
11216  bool ShowProjection(Camera::Projection & out_type) const;
11217 
11223  bool ShowProjection(Camera::Projection & out_type, float & out_oblique_y_skew, float & out_oblique_x_skew) const;
11224 
11228  bool ShowWidth(float & out_width) const;
11229 
11233  bool ShowHeight(float & out_height) const;
11234 
11239  bool ShowField(float & out_width, float & out_height) const;
11240 
11244  bool ShowNearLimit(float & out_near_limit) const;
11245 
11252  CameraKit & Dolly(float in_x_dir, float in_up, float in_forward);
11253 
11260  CameraKit & Orbit(float in_theta, float in_phi);
11261 
11268  CameraKit & Pan(float in_theta, float in_phi);
11269 
11275  CameraKit & Roll(float in_theta);
11276 
11282  CameraKit & Zoom(float in_zoom);
11283 };
11284 
11288 class HPS_API CameraControl : public Control
11289 {
11290 public:
11292  explicit CameraControl(SegmentKey & in_seg);
11293 
11295  CameraControl(CameraControl const & in_that);
11296 
11300  CameraControl(CameraControl && in_that);
11301 
11305  CameraControl & operator=(CameraControl && in_that);
11306 
11308  ~CameraControl();
11309 
11310  virtual HPS::Type Type() const { return ObjectType(); }
11311 
11312  static const HPS::Type staticType = HPS::Type::CameraControl;
11313  HPS::Type ObjectType() const {return staticType;};
11314 
11318  CameraControl & operator=(CameraControl const & in_that);
11319 
11324  CameraControl & SetUpVector(Vector const & in_up);
11325 
11330  CameraControl & SetPosition(Point const & in_position);
11331 
11336  CameraControl & SetTarget(Point const & in_target);
11337 
11344  CameraControl & SetProjection(Camera::Projection in_type, float in_oblique_x_skew = 0.0f, float in_oblique_y_skew = 0.0f);
11345 
11351  CameraControl & SetField(float in_width, float in_height);
11352 
11363  CameraControl & SetNearLimit(float in_double);
11364 
11369  CameraControl & UnsetEverything();
11370 
11371 
11375  bool ShowUpVector(Vector & out_up_vector) const;
11376 
11380  bool ShowPosition(Point & out_position) const;
11381 
11385  bool ShowTarget(Point & out_target) const;
11386 
11390  bool ShowProjection(Camera::Projection & out_type) const;
11391 
11397  bool ShowProjection(Camera::Projection & out_type, float & out_oblique_x_skew, float & out_oblique_y_skew) const;
11398 
11402  bool ShowWidth(float & out_width) const;
11403 
11407  bool ShowHeight(float & out_height) const;
11408 
11413  bool ShowField(float & out_width, float & out_height) const;
11414 
11418  bool ShowNearLimit(float & out_near_limit) const;
11419 
11426  CameraControl & Dolly(float in_x_dir, float in_up, float in_forward);
11427 
11434  CameraControl & Orbit(float in_theta, float in_phi);
11435 
11442  CameraControl & Pan(float in_theta, float in_phi);
11443 
11449  CameraControl & Roll(float in_theta);
11450 
11456  CameraControl & Zoom(float in_zoom);
11457 
11458 private:
11460  CameraControl();
11461 };
11462 
11463 
11464 
11466 class HPS_API SelectabilityKit : public Kit
11467 {
11468 public:
11469 
11471  SelectabilityKit();
11472 
11475  SelectabilityKit(SelectabilityKit const & in_kit);
11476 
11480  SelectabilityKit(SelectabilityKit && in_that);
11481 
11485  SelectabilityKit & operator=(SelectabilityKit && in_that);
11486 
11488  virtual ~SelectabilityKit();
11489 
11490  static const HPS::Type staticType = HPS::Type::SelectabilityKit;
11491  HPS::Type ObjectType() const {return staticType;};
11492 
11496  static SelectabilityKit GetDefault();
11497 
11500  void Set(SelectabilityKit const & in_kit);
11501 
11504  void Show(SelectabilityKit & out_kit) const;
11505 
11509  SelectabilityKit & operator=(SelectabilityKit const & in_kit);
11510 
11513  bool Empty() const;
11514 
11518  bool Equals(SelectabilityKit const & in_kit) const;
11519 
11523  bool operator==(SelectabilityKit const & in_kit) const;
11524 
11528  bool operator!=(SelectabilityKit const & in_kit) const;
11529 
11530 
11534  SelectabilityKit & SetWindows(Selectability::Value in_val);
11535 
11539  SelectabilityKit & SetWindows(bool in_val);
11540 
11544  SelectabilityKit & SetEdges(Selectability::Value in_val);
11545 
11549  SelectabilityKit & SetEdges(bool in_val);
11550 
11554  SelectabilityKit & SetFaces(Selectability::Value in_val);
11555 
11559  SelectabilityKit & SetFaces(bool in_val);
11560 
11564  SelectabilityKit & SetLights(Selectability::Value in_val);
11565 
11569  SelectabilityKit & SetLights(bool in_val);
11570 
11574  SelectabilityKit & SetLines(Selectability::Value in_val);
11575 
11579  SelectabilityKit & SetLines(bool in_val);
11580 
11584  SelectabilityKit & SetMarkers(Selectability::Value in_val);
11585 
11589  SelectabilityKit & SetMarkers(bool in_val);
11590 
11594  SelectabilityKit & SetVertices(Selectability::Value in_val);
11595 
11599  SelectabilityKit & SetVertices(bool in_val);
11600 
11604  SelectabilityKit & SetText(Selectability::Value in_val);
11605 
11609  SelectabilityKit & SetText(bool in_val);
11610 
11614  SelectabilityKit & SetGeometry(Selectability::Value in_val);
11615 
11619  SelectabilityKit & SetGeometry(bool in_val);
11620 
11624  SelectabilityKit & SetEverything(Selectability::Value in_val);
11625 
11629  SelectabilityKit & SetEverything(bool in_val);
11630 
11631 
11634  SelectabilityKit & UnsetWindows();
11635 
11638  SelectabilityKit & UnsetEdges();
11639 
11642  SelectabilityKit & UnsetFaces();
11643 
11646  SelectabilityKit & UnsetLights();
11647 
11650  SelectabilityKit & UnsetLines();
11651 
11654  SelectabilityKit & UnsetMarkers();
11655 
11658  SelectabilityKit & UnsetVertices();
11659 
11662  SelectabilityKit & UnsetText();
11663 
11666  SelectabilityKit & UnsetGeometry();
11667 
11670  SelectabilityKit & UnsetEverything();
11671 
11672 
11676  bool ShowWindows(Selectability::Value & out_val) const;
11677 
11681  bool ShowEdges(Selectability::Value & out_val) const;
11682 
11686  bool ShowFaces(Selectability::Value & out_val) const;
11687 
11691  bool ShowLights(Selectability::Value & out_val) const;
11692 
11696  bool ShowLines(Selectability::Value & out_val) const;
11697 
11701  bool ShowMarkers(Selectability::Value & out_val) const;
11702 
11706  bool ShowVertices(Selectability::Value & out_val) const;
11707 
11711  bool ShowText(Selectability::Value & out_val) const;
11712 };
11713 
11719 class HPS_API SelectabilityControl : public Control
11720 {
11721 public:
11722 
11724  explicit SelectabilityControl(SegmentKey & in_seg);
11725 
11727  SelectabilityControl(SelectabilityControl const & in_that);
11728 
11733 
11737  SelectabilityControl & operator=(SelectabilityControl && in_that);
11738 
11741 
11742  virtual HPS::Type Type() const { return ObjectType(); }
11743 
11744  static const HPS::Type staticType = HPS::Type::SelectabilityControl;
11745  HPS::Type ObjectType() const {return staticType;};
11746 
11750  SelectabilityControl & operator=(SelectabilityControl const & in_that);
11751 
11755  SelectabilityControl & SetWindows(Selectability::Value in_val);
11756 
11760  SelectabilityControl & SetWindows(bool in_val);
11761 
11765  SelectabilityControl & SetEdges(Selectability::Value in_val);
11766 
11770  SelectabilityControl & SetEdges(bool in_val);
11771 
11775  SelectabilityControl & SetFaces(Selectability::Value in_val);
11776 
11780  SelectabilityControl & SetFaces(bool in_val);
11781 
11785  SelectabilityControl & SetLights(Selectability::Value in_val);
11786 
11790  SelectabilityControl & SetLights(bool in_val);
11791 
11795  SelectabilityControl & SetLines(Selectability::Value in_val);
11796 
11800  SelectabilityControl & SetLines(bool in_val);
11801 
11805  SelectabilityControl & SetMarkers(Selectability::Value in_val);
11806 
11810  SelectabilityControl & SetMarkers(bool in_val);
11811 
11815  SelectabilityControl & SetVertices(Selectability::Value in_val);
11816 
11820  SelectabilityControl & SetVertices(bool in_val);
11821 
11825  SelectabilityControl & SetText(Selectability::Value in_val);
11826 
11830  SelectabilityControl & SetText(bool in_val);
11831 
11835  SelectabilityControl & SetGeometry(Selectability::Value in_val);
11836 
11840  SelectabilityControl & SetGeometry(bool in_val);
11841 
11845  SelectabilityControl & SetEverything(Selectability::Value in_val);
11846 
11850  SelectabilityControl & SetEverything(bool in_val);
11851 
11852 
11856  SelectabilityControl & UnsetWindows();
11857 
11861  SelectabilityControl & UnsetEdges();
11862 
11866  SelectabilityControl & UnsetFaces();
11867 
11871  SelectabilityControl & UnsetLights();
11872 
11876  SelectabilityControl & UnsetLines();
11877 
11881  SelectabilityControl & UnsetMarkers();
11882 
11886  SelectabilityControl & UnsetVertices();
11887 
11891  SelectabilityControl & UnsetText();
11892 
11896  SelectabilityControl & UnsetGeometry();
11897 
11901  SelectabilityControl & UnsetEverything();
11902 
11903 
11907  bool ShowWindows(Selectability::Value & out_val) const;
11908 
11912  bool ShowEdges(Selectability::Value & out_val) const;
11913 
11917  bool ShowFaces(Selectability::Value & out_val) const;
11918 
11922  bool ShowLights(Selectability::Value & out_val) const;
11923 
11927  bool ShowLines(Selectability::Value & out_val) const;
11928 
11932  bool ShowMarkers(Selectability::Value & out_val) const;
11933 
11937  bool ShowVertices(Selectability::Value & out_val) const;
11938 
11942  bool ShowText(Selectability::Value & out_val) const;
11943 
11944 private:
11947 };
11948 
11949 
11951 class HPS_API TransparencyKit : public Kit
11952 {
11953 public:
11954 
11956  TransparencyKit();
11957 
11960  TransparencyKit(TransparencyKit const & in_kit);
11961 
11965  TransparencyKit(TransparencyKit && in_that);
11966 
11970  TransparencyKit & operator=(TransparencyKit && in_that);
11971 
11973  virtual ~TransparencyKit();
11974 
11975  static const HPS::Type staticType = HPS::Type::TransparencyKit;
11976  HPS::Type ObjectType() const {return staticType;};
11977 
11981  static TransparencyKit GetDefault();
11982 
11985  void Set(TransparencyKit const & in_kit);
11986 
11989  void Show(TransparencyKit & out_kit) const;
11990 
11994  TransparencyKit & operator=(TransparencyKit const & in_kit);
11995 
11998  bool Empty() const;
11999 
12003  bool Equals(TransparencyKit const & in_kit) const;
12004 
12008  bool operator==(TransparencyKit const & in_kit) const;
12009 
12013  bool operator!=(TransparencyKit const & in_kit) const;
12014 
12015 
12019  TransparencyKit & SetMethod(Transparency::Method in_style);
12020 
12024  TransparencyKit & SetAlgorithm(Transparency::Algorithm in_algorithm);
12025 
12031  TransparencyKit & SetDepthPeelingLayers(unsigned int in_layers);
12032 
12037  TransparencyKit & SetDepthPeelingPreference(Transparency::Preference in_preference);
12038 
12044  TransparencyKit & SetDepthPeelingMinimumArea(float in_area, Transparency::AreaUnits in_units);
12045 
12050  TransparencyKit & SetDepthWriting(bool in_state);
12051 
12052 
12055  TransparencyKit & UnsetMethod();
12056 
12059  TransparencyKit & UnsetAlgorithm();
12060 
12063  TransparencyKit & UnsetDepthPeelingLayers();
12064 
12067  TransparencyKit & UnsetDepthPeelingMinimumArea();
12068 
12071  TransparencyKit & UnsetDepthWriting();
12072 
12075  TransparencyKit & UnsetDepthPeelingPreference();
12076 
12079  TransparencyKit & UnsetEverything();
12080 
12081 
12085  bool ShowMethod(Transparency::Method & out_style) const;
12086 
12090  bool ShowAlgorithm(Transparency::Algorithm & out_algorithm) const;
12091 
12095  bool ShowDepthPeelingLayers(unsigned int & out_layers) const;
12096 
12101  bool ShowDepthPeelingMinimumArea(float & out_area, Transparency::AreaUnits & out_units) const;
12102 
12106  bool ShowDepthWriting(bool & out_state) const;
12107 
12111  bool ShowDepthPeelingPreference(Transparency::Preference & out_preference) const;
12112 };
12113 
12119 class HPS_API TransparencyControl : public Control
12120 {
12121 public:
12122 
12124  explicit TransparencyControl(SegmentKey & in_seg);
12125 
12127  TransparencyControl(TransparencyControl const & in_that);
12128 
12133 
12137  TransparencyControl & operator=(TransparencyControl && in_that);
12138 
12141 
12142  virtual HPS::Type Type() const { return ObjectType(); }
12143 
12144  static const HPS::Type staticType = HPS::Type::TransparencyControl;
12145  HPS::Type ObjectType() const {return staticType;};
12146 
12150  TransparencyControl & operator=(TransparencyControl const & in_that);
12151 
12155  TransparencyControl & SetMethod(Transparency::Method in_style);
12156 
12160  TransparencyControl & SetAlgorithm(Transparency::Algorithm in_algorithm);
12161 
12167  TransparencyControl & SetDepthPeelingLayers(unsigned int in_layers);
12168 
12174  TransparencyControl & SetDepthPeelingMinimumArea(float in_area, Transparency::AreaUnits in_units);
12175 
12180  TransparencyControl & SetDepthWriting(bool in_state);
12181 
12186  TransparencyControl & SetDepthPeelingPreference(Transparency::Preference in_preference);
12187 
12191  TransparencyControl & UnsetMethod();
12192 
12196  TransparencyControl & UnsetAlgorithm();
12197 
12201  TransparencyControl & UnsetDepthPeelingLayers();
12202 
12206  TransparencyControl & UnsetDepthPeelingMinimumArea();
12207 
12211  TransparencyControl & UnsetDepthWriting();
12212 
12216  TransparencyControl & UnsetDepthPeelingPreference();
12217 
12221  TransparencyControl & UnsetEverything();
12222 
12226  bool ShowMethod(Transparency::Method & out_style) const;
12227 
12231  bool ShowAlgorithm(Transparency::Algorithm & out_algorithm) const;
12232 
12236  bool ShowDepthPeelingLayers(unsigned int & out_layers) const;
12237 
12242  bool ShowDepthPeelingMinimumArea(float & out_area, Transparency::AreaUnits & out_units) const;
12243 
12247  bool ShowDepthWriting(bool & out_state) const;
12248 
12252  bool ShowDepthPeelingPreference(Transparency::Preference & out_preference) const;
12253 
12254 private:
12257 };
12258 
12260 class HPS_API ColorInterpolationKit : public Kit
12261 {
12262 public:
12263 
12266 
12269 
12274 
12278  ColorInterpolationKit & operator=(ColorInterpolationKit && in_that);
12279 
12281  virtual ~ColorInterpolationKit();
12282 
12283  static const HPS::Type staticType = HPS::Type::ColorInterpolationKit;
12284  HPS::Type ObjectType() const {return staticType;};
12285 
12286  static ColorInterpolationKit GetDefault();
12287 
12289  void Set(ColorInterpolationKit const & in_kit);
12290 
12292  void Show(ColorInterpolationKit & out_kit) const;
12293 
12295  ColorInterpolationKit & operator=(ColorInterpolationKit const & in_kit);
12296 
12298  bool Empty() const;
12299 
12301  bool Equals(ColorInterpolationKit const & in_kit) const;
12302 
12304  bool operator==(ColorInterpolationKit const & in_kit) const;
12305 
12307  bool operator!=(ColorInterpolationKit const & in_kit) const;
12308 
12309 
12313  ColorInterpolationKit & SetFaceColor(bool in_state);
12314 
12318  ColorInterpolationKit & SetEdgeColor(bool in_state);
12319 
12323  ColorInterpolationKit & SetVertexColor(bool in_state);
12324 
12328  ColorInterpolationKit & SetFaceIndex(bool in_state);
12329 
12333  ColorInterpolationKit & SetEdgeIndex(bool in_state);
12334 
12338  ColorInterpolationKit & SetVertexIndex(bool in_state);
12339 
12340 
12343  ColorInterpolationKit & UnsetFaceColor();
12344 
12347  ColorInterpolationKit & UnsetEdgeColor();
12348 
12351  ColorInterpolationKit & UnsetVertexColor();
12352 
12355  ColorInterpolationKit & UnsetFaceIndex();
12356 
12359  ColorInterpolationKit & UnsetEdgeIndex();
12360 
12363  ColorInterpolationKit & UnsetVertexIndex();
12364 
12367  ColorInterpolationKit & UnsetEverything();
12368 
12369 
12373  bool ShowFaceColor(bool & out_state) const;
12374 
12378  bool ShowEdgeColor(bool & out_state) const;
12379 
12383  bool ShowVertexColor(bool & out_state) const;
12384 
12388  bool ShowFaceIndex(bool & out_state) const;
12389 
12393  bool ShowEdgeIndex(bool & out_state) const;
12394 
12398  bool ShowVertexIndex(bool & out_state) const;
12399 };
12400 
12401 
12405 class HPS_API ColorInterpolationControl : public Control
12406 {
12407 public:
12408 
12410  explicit ColorInterpolationControl(SegmentKey & in_seg);
12411 
12414 
12419 
12423  ColorInterpolationControl & operator=(ColorInterpolationControl && in_that);
12424 
12427 
12428  virtual HPS::Type Type() const { return ObjectType(); }
12429 
12430  static const HPS::Type staticType = HPS::Type::ColorInterpolationControl;
12431  HPS::Type ObjectType() const {return staticType;};
12432 
12436  ColorInterpolationControl & operator=(ColorInterpolationControl const & in_that);
12437 
12441  ColorInterpolationControl & SetFaceColor(bool in_state);
12442 
12446  ColorInterpolationControl & SetEdgeColor(bool in_state);
12447 
12451  ColorInterpolationControl & SetVertexColor(bool in_state);
12452 
12456  ColorInterpolationControl & SetFaceIndex(bool in_state);
12457 
12461  ColorInterpolationControl & SetEdgeIndex(bool in_state);
12462 
12466  ColorInterpolationControl & SetVertexIndex(bool in_state);
12467 
12468 
12472  ColorInterpolationControl & UnsetFaceColor();
12473 
12477  ColorInterpolationControl & UnsetEdgeColor();
12478 
12482  ColorInterpolationControl & UnsetVertexColor();
12483 
12487  ColorInterpolationControl & UnsetFaceIndex();
12488 
12492  ColorInterpolationControl & UnsetEdgeIndex();
12493 
12497  ColorInterpolationControl & UnsetVertexIndex();
12498 
12502  ColorInterpolationControl & UnsetEverything();
12503 
12504 
12508  bool ShowFaceColor(bool & out_state) const;
12509 
12513  bool ShowEdgeColor(bool & out_state) const;
12514 
12518  bool ShowVertexColor(bool & out_state) const;
12519 
12523  bool ShowFaceIndex(bool & out_state) const;
12524 
12528  bool ShowEdgeIndex(bool & out_state) const;
12529 
12533  bool ShowVertexIndex(bool & out_state) const;
12534 
12535 private:
12538 };
12539 
12540 
12542 class HPS_API CullingKit : public Kit
12543 {
12544 public:
12545 
12547  CullingKit();
12548 
12551  CullingKit(CullingKit const & in_kit);
12552 
12556  CullingKit(CullingKit && in_that);
12557 
12561  CullingKit & operator=(CullingKit && in_that);
12562 
12564  virtual ~CullingKit();
12565 
12566  static const HPS::Type staticType = HPS::Type::CullingKit;
12567  HPS::Type ObjectType() const {return staticType;};
12568 
12572  static CullingKit GetDefault();
12573 
12576  void Set(CullingKit const & in_kit);
12577 
12580  void Show(CullingKit & out_kit) const;
12581 
12585  CullingKit & operator=(CullingKit const & in_kit);
12586 
12589  bool Empty() const;
12590 
12594  bool Equals(CullingKit const & in_kit) const;
12595 
12599  bool operator==(CullingKit const & in_kit) const;
12600 
12604  bool operator!=(CullingKit const & in_kit) const;
12605 
12610  CullingKit & SetDeferralExtent(bool in_state, unsigned int in_pixels);
12611 
12616  CullingKit & SetDeferralExtent(unsigned int in_pixels);
12617 
12622  CullingKit & SetExtent(bool in_state, unsigned int in_pixels);
12623 
12628  CullingKit & SetExtent(unsigned int in_pixels);
12629 
12633  CullingKit & SetBackFace(bool in_state);
12634 
12641  CullingKit & SetVector(bool in_state, HPS::Vector const & in_vector, float in_tolerance_degrees);
12642 
12649  CullingKit & SetVector(HPS::Vector const & in_vector, float in_tolerance_degrees);
12650 
12657  CullingKit & SetVector(bool in_state, HPS::Vector const & in_vector = Vector(0.0f, 0.0f, 1.0f));
12658 
12664  CullingKit & SetVector(HPS::Vector const & in_vector);
12665 
12669  CullingKit & SetVectorTolerance(float in_tolerance_degrees);
12670 
12674  CullingKit & SetFrustum(bool in_state);
12675 
12683  CullingKit & SetVolume(bool in_state, HPS::SimpleCuboid const & in_volume = HPS::SimpleCuboid());
12684 
12691  CullingKit & SetVolume(HPS::SimpleCuboid const & in_volume);
12692 
12700  CullingKit & SetDistance(bool in_state, float in_max_distance);
12701 
12709  CullingKit & SetDistance(float in_max_distance);
12710 
12713  CullingKit & UnsetDeferralExtent();
12714 
12717  CullingKit & UnsetExtent();
12718 
12721  CullingKit & UnsetBackFace();
12722 
12725  CullingKit & UnsetVector();
12726 
12729  CullingKit & UnsetVectorTolerance();
12730 
12733  CullingKit & UnsetFrustum();
12734 
12737  CullingKit & UnsetVolume();
12738 
12741  CullingKit & UnsetDistance();
12742 
12745  CullingKit & UnsetEverything();
12746 
12751  bool ShowDeferralExtent(bool & out_state, unsigned int & out_pixels) const;
12752 
12757  bool ShowExtent(bool & out_state, unsigned int & out_pixels) const;
12758 
12762  bool ShowBackFace(bool & out_state) const;
12763 
12769  bool ShowVector(bool & out_state, HPS::Vector & out_vector) const;
12770 
12774  bool ShowVectorTolerance(float & out_tolerance_degrees) const;
12775 
12779  bool ShowFrustum(bool & out_state) const;
12780 
12786  bool ShowVolume(bool & out_state, HPS::SimpleCuboid & out_volume) const;
12787 
12793  bool ShowDistance(bool & out_state, float & out_max_distance) const;
12794 };
12795 
12799 class HPS_API CullingControl : public Control
12800 {
12801 public:
12802 
12804  explicit CullingControl(SegmentKey & in_seg);
12805 
12807  CullingControl(CullingControl const & in_that);
12808 
12810  ~CullingControl();
12811 
12815  CullingControl(CullingControl && in_that);
12816 
12820  CullingControl & operator=(CullingControl && in_that);
12821 
12822  virtual HPS::Type Type() const { return ObjectType(); }
12823 
12824  static const HPS::Type staticType = HPS::Type::CullingControl;
12825  HPS::Type ObjectType() const {return staticType;};
12826 
12830  CullingControl & operator=(CullingControl const & in_that);
12831 
12838  CullingControl & SetDeferralExtent(bool in_state, unsigned int in_pixels);
12839 
12846  CullingControl & SetDeferralExtent(unsigned int in_pixels);
12847 
12852  CullingControl & SetExtent(bool in_state, unsigned int in_pixels);
12853 
12858  CullingControl & SetExtent(unsigned int in_pixels);
12859 
12864  CullingControl & SetBackFace(bool in_state);
12865 
12872  CullingControl & SetVector(bool in_state, HPS::Vector const & in_vector, float in_tolerance_degrees);
12873 
12880  CullingControl & SetVector(HPS::Vector const & in_vector, float in_tolerance_degrees);
12881 
12888  CullingControl & SetVector(bool in_state, HPS::Vector const & in_vector = Vector(0.0f, 0.0f, 1.0f));
12889 
12895  CullingControl & SetVector(HPS::Vector const & in_vector);
12896 
12900  CullingControl & SetVectorTolerance(float in_tolerance_degrees);
12901 
12905  CullingControl & SetFrustum(bool in_state);
12906 
12914  CullingControl & SetVolume(bool in_state, HPS::SimpleCuboid const & in_volume = HPS::SimpleCuboid());
12915 
12922  CullingControl & SetVolume(HPS::SimpleCuboid const & in_volume);
12923 
12931  CullingControl & SetDistance(bool in_state, float in_max_distance);
12932 
12940  CullingControl & SetDistance(float in_max_distance);
12941 
12945  CullingControl & UnsetDeferralExtent();
12946 
12950  CullingControl & UnsetExtent();
12951 
12955  CullingControl & UnsetBackFace();
12956 
12960  CullingControl & UnsetVector();
12961 
12965  CullingControl & UnsetVectorTolerance();
12966 
12970  CullingControl & UnsetFrustum();
12971 
12975  CullingControl & UnsetVolume();
12976 
12980  CullingControl & UnsetDistance();
12981 
12985  CullingControl & UnsetEverything();
12986 
12991  bool ShowDeferralExtent(bool & out_state, unsigned int & out_pixels) const;
12992 
12997  bool ShowExtent(bool & out_state, unsigned int & out_pixels) const;
12998 
13002  bool ShowBackFace(bool & out_state) const;
13003 
13009  bool ShowVector(bool & out_state, HPS::Vector & out_vector) const;
13010 
13014  bool ShowVectorTolerance(float & out_tolerance_degrees) const;
13015 
13019  bool ShowFrustum(bool & out_state) const;
13020 
13026  bool ShowVolume(bool & out_state, HPS::SimpleCuboid & out_volume) const;
13027 
13033  bool ShowDistance(bool & out_state, float & out_max_distance) const;
13034 
13035 private:
13037  CullingControl();
13038 };
13039 
13040 
13041 
13042 
13044 class HPS_API MarkerAttributeKit : public Kit
13045 {
13046 public:
13047 
13050 
13053  MarkerAttributeKit(MarkerAttributeKit const & in_kit);
13054 
13059 
13063  MarkerAttributeKit & operator=(MarkerAttributeKit && in_that);
13064 
13066  virtual ~MarkerAttributeKit();
13067 
13068  static const HPS::Type staticType = HPS::Type::MarkerAttributeKit;
13069  HPS::Type ObjectType() const {return staticType;};
13070 
13074  static MarkerAttributeKit GetDefault();
13075 
13078  void Set(MarkerAttributeKit const & in_kit);
13079 
13082  void Show(MarkerAttributeKit & out_kit) const;
13083 
13087  MarkerAttributeKit & operator=(MarkerAttributeKit const & in_kit);
13088 
13091  bool Empty() const;
13092 
13096  bool Equals(MarkerAttributeKit const & in_kit) const;
13097 
13101  bool operator==(MarkerAttributeKit const & in_kit) const;
13102 
13106  bool operator!=(MarkerAttributeKit const & in_kit) const;
13107 
13108 
13112  MarkerAttributeKit & SetSymbol(char const * in_glyph_name);
13113 
13118  MarkerAttributeKit & SetSize(float in_size, Marker::SizeUnits in_units = Marker::SizeUnits::ScaleFactor);
13119 
13123  MarkerAttributeKit & SetDrawingPreference(Marker::DrawingPreference in_preference);
13124 
13128  MarkerAttributeKit & SetGlyphRotation(float in_rotation);
13129 
13132  MarkerAttributeKit & UnsetSymbol();
13133 
13136  MarkerAttributeKit & UnsetSize();
13137 
13140  MarkerAttributeKit & UnsetDrawingPreference();
13141 
13144  MarkerAttributeKit & UnsetGlyphRotation();
13145 
13148  MarkerAttributeKit & UnsetEverything();
13149 
13153  bool ShowSymbol(UTF8 & out_glyph_name) const;
13154 
13159  bool ShowSize(float & out_size, Marker::SizeUnits & out_units) const;
13160 
13164  bool ShowDrawingPreference(Marker::DrawingPreference & out_preference) const;
13165 
13169  bool ShowGlyphRotation(float & out_rotation) const;
13170 };
13171 
13177 class HPS_API MarkerAttributeControl : public Control
13178 {
13179 public:
13180 
13182  explicit MarkerAttributeControl(SegmentKey & in_seg);
13183 
13186 
13191 
13195  MarkerAttributeControl & operator=(MarkerAttributeControl && in_that);
13196 
13199 
13200  virtual HPS::Type Type() const { return ObjectType(); }
13201 
13202  static const HPS::Type staticType = HPS::Type::MarkerAttributeControl;
13203  HPS::Type ObjectType() const {return staticType;};
13204 
13208  MarkerAttributeControl & operator=(MarkerAttributeControl const & in_that);
13209 
13213  MarkerAttributeControl & SetSymbol(char const * in_glyph_name);
13214 
13219  MarkerAttributeControl & SetSize(float in_size, Marker::SizeUnits in_units = Marker::SizeUnits::ScaleFactor);
13220 
13224  MarkerAttributeControl & SetDrawingPreference(Marker::DrawingPreference in_preference);
13225 
13229  MarkerAttributeControl & SetGlyphRotation(float in_rotation);
13230 
13234  MarkerAttributeControl & UnsetSymbol();
13235 
13239  MarkerAttributeControl & UnsetSize();
13240 
13243  MarkerAttributeControl & UnsetDrawingPreference();
13244 
13247  MarkerAttributeControl & UnsetGlyphRotation();
13248 
13252  MarkerAttributeControl & UnsetEverything();
13253 
13254 
13258  bool ShowSymbol(UTF8 & out_glyph_name) const;
13259 
13264  bool ShowSize(float & out_size, Marker::SizeUnits & out_units) const;
13265 
13269  bool ShowDrawingPreference(Marker::DrawingPreference & out_preference) const;
13270 
13274  bool ShowGlyphRotation(float & out_rotation) const;
13275 
13276 private:
13279 };
13280 
13281 
13283 class HPS_API SphereAttributeKit : public Kit
13284 {
13285 public:
13286 
13289 
13292  SphereAttributeKit(SphereAttributeKit const & in_kit);
13293 
13298 
13302  SphereAttributeKit & operator=(SphereAttributeKit && in_that);
13303 
13305  virtual ~SphereAttributeKit();
13306 
13307  static const HPS::Type staticType = HPS::Type::SphereAttributeKit;
13308  HPS::Type ObjectType() const {return staticType;};
13309 
13313  static SphereAttributeKit GetDefault();
13314 
13317  void Set(SphereAttributeKit const & in_kit);
13318 
13321  void Show(SphereAttributeKit & out_kit) const;
13322 
13326  SphereAttributeKit & operator=(SphereAttributeKit const & in_kit);
13327 
13330  bool Empty() const;
13331 
13335  bool Equals(SphereAttributeKit const & in_kit) const;
13336 
13340  bool operator==(SphereAttributeKit const & in_kit) const;
13341 
13345  bool operator!=(SphereAttributeKit const & in_kit) const;
13346 
13347 
13351  SphereAttributeKit & SetTessellation(size_t in_facets);
13352 
13353 
13356  SphereAttributeKit & UnsetTessellation();
13357 
13360  SphereAttributeKit & UnsetEverything();
13361 
13362 
13366  bool ShowTessellation(size_t & out_facets) const;
13367 };
13368 
13369 
13372 class HPS_API SphereAttributeControl : public Control
13373 {
13374 public:
13375 
13377  explicit SphereAttributeControl(SegmentKey const & in_seg);
13378 
13381 
13386 
13390  SphereAttributeControl & operator=(SphereAttributeControl && in_that);
13391 
13394 
13395  virtual HPS::Type Type() const { return ObjectType(); }
13396 
13397  static const HPS::Type staticType = HPS::Type::SphereAttributeControl;
13398  HPS::Type ObjectType() const {return staticType;};
13399 
13403  SphereAttributeControl & operator=(SphereAttributeControl const & in_that);
13404 
13409  SphereAttributeControl & SetTessellation(size_t in_facets);
13410 
13411 
13415  SphereAttributeControl & UnsetTessellation();
13416 
13420  SphereAttributeControl & UnsetEverything();
13421 
13422 
13426  bool ShowTessellation(size_t & out_facets) const;
13427 
13428 private:
13431 };
13432 
13433 
13435 class HPS_API LightingAttributeKit : public Kit
13436 {
13437 public:
13438 
13441 
13445 
13450 
13454  LightingAttributeKit & operator=(LightingAttributeKit && in_that);
13455 
13457  virtual ~LightingAttributeKit();
13458 
13459  static const HPS::Type staticType = HPS::Type::LightingAttributeKit;
13460  HPS::Type ObjectType() const {return staticType;};
13461 
13465  static LightingAttributeKit GetDefault();
13466 
13469  void Set(LightingAttributeKit const & in_kit);
13470 
13473  void Show(LightingAttributeKit & out_kit) const;
13474 
13478  LightingAttributeKit & operator=(LightingAttributeKit const & in_kit);
13479 
13482  bool Empty() const;
13483 
13487  bool Equals(LightingAttributeKit const & in_kit) const;
13488 
13492  bool operator==(LightingAttributeKit const & in_kit) const;
13493 
13497  bool operator!=(LightingAttributeKit const & in_kit) const;
13498 
13499 
13503  LightingAttributeKit & SetInterpolationAlgorithm(Lighting::InterpolationAlgorithm in_interpolation);
13504 
13505 
13508  LightingAttributeKit & UnsetInterpolationAlgorithm();
13509 
13512  LightingAttributeKit & UnsetEverything();
13513 
13514 
13518  bool ShowInterpolationAlgorithm(Lighting::InterpolationAlgorithm & out_interpolation) const;
13519 };
13520 
13521 
13522 
13528 class HPS_API LightingAttributeControl : public Control
13529 {
13530 public:
13531 
13533  explicit LightingAttributeControl(SegmentKey & in_seg);
13534 
13537 
13542 
13546  LightingAttributeControl & operator=(LightingAttributeControl && in_that);
13547 
13550 
13551  virtual HPS::Type Type() const { return ObjectType(); }
13552 
13553  static const HPS::Type staticType = HPS::Type::LightingAttributeControl;
13554  HPS::Type ObjectType() const {return staticType;};
13555 
13559  LightingAttributeControl & operator=(LightingAttributeControl const & in_that);
13560 
13564  LightingAttributeControl & SetInterpolationAlgorithm(Lighting::InterpolationAlgorithm in_interpolation);
13565 
13566 
13570  LightingAttributeControl & UnsetInterpolationAlgorithm();
13571 
13575  LightingAttributeControl & UnsetEverything();
13576 
13577 
13581  bool ShowInterpolationAlgorithm(Lighting::InterpolationAlgorithm & out_interpolation) const;
13582 
13583 private:
13586 };
13587 
13588 
13589 
13591 class HPS_API CylinderAttributeKit : public Kit
13592 {
13593 public:
13594 
13597 
13601 
13606 
13610  CylinderAttributeKit & operator=(CylinderAttributeKit && in_that);
13611 
13613  virtual ~CylinderAttributeKit();
13614 
13615  static const HPS::Type staticType = HPS::Type::CylinderAttributeKit;
13616  HPS::Type ObjectType() const {return staticType;};
13617 
13621  static CylinderAttributeKit GetDefault();
13622 
13625  void Set(CylinderAttributeKit const & in_kit);
13626 
13629  void Show(CylinderAttributeKit & out_kit) const;
13630 
13634  CylinderAttributeKit & operator=(CylinderAttributeKit const & in_kit);
13635 
13638  bool Empty() const;
13639 
13643  bool Equals(CylinderAttributeKit const & in_kit) const;
13644 
13648  bool operator==(CylinderAttributeKit const & in_kit) const;
13649 
13653  bool operator!=(CylinderAttributeKit const & in_kit) const;
13654 
13655 
13659  CylinderAttributeKit & SetTessellation(size_t in_facets);
13660 
13665  CylinderAttributeKit & SetOrientation(Cylinder::Orientation in_adjust);
13666 
13667 
13670  CylinderAttributeKit & UnsetTessellation();
13671 
13674  CylinderAttributeKit & UnsetOrientation();
13675 
13678  CylinderAttributeKit & UnsetEverything();
13679 
13680 
13684  bool ShowTessellation(size_t & out_facets) const;
13685 
13689  bool ShowOrientation(Cylinder::Orientation & out_orientation) const;
13690 };
13691 
13692 
13693 
13697 class HPS_API CylinderAttributeControl : public Control
13698 {
13699 public:
13700 
13702  explicit CylinderAttributeControl(SegmentKey & in_seg);
13703 
13706 
13711 
13715  CylinderAttributeControl & operator=(CylinderAttributeControl && in_that);
13716 
13719 
13720  virtual HPS::Type Type() const { return ObjectType(); }
13721 
13722  static const HPS::Type staticType = HPS::Type::CylinderAttributeControl;
13723  HPS::Type ObjectType() const {return staticType;};
13724 
13728  CylinderAttributeControl & operator=(CylinderAttributeControl const & in_that);
13729 
13733  CylinderAttributeControl & SetTessellation(size_t in_facets);
13734 
13739  CylinderAttributeControl & SetOrientation(Cylinder::Orientation in_orientation);
13740 
13741 
13745  CylinderAttributeControl & UnsetTessellation();
13746 
13750  CylinderAttributeControl & UnsetOrientation();
13751 
13755  CylinderAttributeControl & UnsetEverything();
13756 
13757 
13761  bool ShowTessellation(size_t & out_facets) const;
13762 
13766  bool ShowOrientation(Cylinder::Orientation & out_adjust) const;
13767 
13768 private:
13771 };
13772 
13773 
13774 
13776 class HPS_API CuttingSectionAttributeKit : public Kit
13777 {
13778 public:
13779 
13782 
13786 
13791 
13796 
13798  virtual ~CuttingSectionAttributeKit();
13799 
13800  static const HPS::Type staticType = HPS::Type::CuttingSectionAttributeKit;
13801  HPS::Type ObjectType() const {return staticType;};
13802 
13806  static CuttingSectionAttributeKit GetDefault();
13807 
13810  void Set(CuttingSectionAttributeKit const & in_kit);
13811 
13814  void Show(CuttingSectionAttributeKit & out_kit) const;
13815 
13819  CuttingSectionAttributeKit & operator=(CuttingSectionAttributeKit const & in_kit);
13820 
13823  bool Empty() const;
13824 
13828  bool Equals(CuttingSectionAttributeKit const & in_kit) const;
13829 
13833  bool operator==(CuttingSectionAttributeKit const & in_kit) const;
13834 
13838  bool operator!=(CuttingSectionAttributeKit const & in_kit) const;
13839 
13844  CuttingSectionAttributeKit & SetEdgeWeight(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
13845 
13850  CuttingSectionAttributeKit & SetTolerance(float in_tolerance, CuttingSection::ToleranceUnits in_units);
13851 
13855  CuttingSectionAttributeKit & SetCuttingLevel(CuttingSection::CuttingLevel in_level);
13856 
13860  CuttingSectionAttributeKit & SetCappingLevel(CuttingSection::CappingLevel in_level);
13861 
13865  CuttingSectionAttributeKit & SetMaterialPreference(CuttingSection::MaterialPreference in_preference);
13866 
13869  CuttingSectionAttributeKit & UnsetEdgeWeight();
13870 
13873  CuttingSectionAttributeKit & UnsetTolerance();
13874 
13877  CuttingSectionAttributeKit & UnsetCuttingLevel();
13878 
13881  CuttingSectionAttributeKit & UnsetCappingLevel();
13882 
13885  CuttingSectionAttributeKit & UnsetMaterialPreference();
13886 
13889  CuttingSectionAttributeKit & UnsetEverything();
13890 
13891 
13895  bool ShowCuttingLevel(CuttingSection::CuttingLevel & out_level) const;
13896 
13900  bool ShowCappingLevel(CuttingSection::CappingLevel & out_level) const;
13901 
13905  bool ShowMaterialPreference(CuttingSection::MaterialPreference & out_preference) const;
13906 
13911  bool ShowEdgeWeight(float & out_weight, Line::SizeUnits & out_units) const;
13912 
13917  bool ShowTolerance(float & out_tolerance, CuttingSection::ToleranceUnits & out_units) const;
13918 };
13919 
13920 
13921 
13926 {
13927 public:
13928 
13930  explicit CuttingSectionAttributeControl(SegmentKey & in_seg);
13931 
13934 
13939 
13944 
13947 
13948  virtual HPS::Type Type() const { return ObjectType(); }
13949 
13950  static const HPS::Type staticType = HPS::Type::CuttingSectionAttributeControl;
13951  HPS::Type ObjectType() const {return staticType;};
13952 
13957 
13962  CuttingSectionAttributeControl & SetEdgeWeight(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
13963 
13968  CuttingSectionAttributeControl & SetTolerance(float in_tolerance, CuttingSection::ToleranceUnits in_units);
13969 
13974 
13979 
13983  CuttingSectionAttributeControl & SetMaterialPreference(CuttingSection::MaterialPreference in_preference);
13984 
13988  CuttingSectionAttributeControl & UnsetEdgeWeight();
13989 
13993  CuttingSectionAttributeControl & UnsetTolerance();
13994 
13995 
13999  CuttingSectionAttributeControl & UnsetCuttingLevel();
14000 
14004  CuttingSectionAttributeControl & UnsetCappingLevel();
14005 
14009  CuttingSectionAttributeControl & UnsetMaterialPreference();
14010 
14014  CuttingSectionAttributeControl & UnsetEverything();
14015 
14016 
14020  bool ShowCuttingLevel(CuttingSection::CuttingLevel & out_level) const;
14021 
14025  bool ShowCappingLevel(CuttingSection::CappingLevel & out_level) const;
14026 
14030  bool ShowMaterialPreference(CuttingSection::MaterialPreference & out_preference) const;
14031 
14036  bool ShowEdgeWeight(float & out_weight, Line::SizeUnits & out_units) const;
14037 
14042  bool ShowTolerance(float & out_tolerance, CuttingSection::ToleranceUnits & out_units) const;
14043 
14044 private:
14047 };
14048 
14049 
14050 
14052 class HPS_API TextAttributeKit : public Kit
14053 {
14054 public:
14055 
14057  TextAttributeKit();
14058 
14061  TextAttributeKit(TextAttributeKit const & in_kit);
14062 
14066  TextAttributeKit(TextAttributeKit && in_that);
14067 
14071  TextAttributeKit & operator=(TextAttributeKit && in_that);
14072 
14074  virtual ~TextAttributeKit();
14075 
14076  static const HPS::Type staticType = HPS::Type::TextAttributeKit;
14077  HPS::Type ObjectType() const {return staticType;};
14078 
14082  static TextAttributeKit GetDefault();
14083 
14086  void Set(TextAttributeKit const & in_kit);
14087 
14090  void Show(TextAttributeKit & out_kit) const;
14091 
14095  TextAttributeKit & operator=(TextAttributeKit const & in_kit);
14096 
14099  bool Empty() const;
14100 
14104  bool Equals(TextAttributeKit const & in_kit) const;
14105 
14109  bool operator==(TextAttributeKit const & in_kit) const;
14110 
14114  bool operator!=(TextAttributeKit const & in_kit) const;
14115 
14116 
14123 
14128  TextAttributeKit & SetBold(bool in_state);
14129 
14134  TextAttributeKit & SetItalic(bool in_state);
14135 
14139  TextAttributeKit & SetOverline(bool in_state);
14140 
14144  TextAttributeKit & SetStrikethrough(bool in_state);
14145 
14149  TextAttributeKit & SetUnderline(bool in_state);
14150 
14156  TextAttributeKit & SetSlant(float in_angle);
14157 
14162  TextAttributeKit & SetLineSpacing(float in_multiplier);
14163 
14169  TextAttributeKit & SetRotation(Text::Rotation in_state, float in_angle = 0.0f);
14170 
14176  TextAttributeKit & SetRotation(float in_angle);
14177 
14183  TextAttributeKit & SetExtraSpace(bool in_state, float in_size = 0.0f, Text::SizeUnits in_units = Text::SizeUnits::ObjectSpace);
14184 
14190  TextAttributeKit & SetExtraSpace(float in_size, Text::SizeUnits in_units);
14191 
14198  TextAttributeKit & SetGreeking(bool in_state, float in_size = 0.0f, Text::GreekingUnits in_units = Text::GreekingUnits::ObjectSpace, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
14199 
14206 
14216  TextAttributeKit & SetSizeTolerance(bool in_state, float in_size = 50.0f, Text::SizeToleranceUnits in_units = Text::SizeToleranceUnits::Percent);
14217 
14227  TextAttributeKit & SetSizeTolerance(float in_size, Text::SizeToleranceUnits in_units);
14228 
14233  TextAttributeKit & SetSize(float in_size, Text::SizeUnits in_units);
14234 
14241  TextAttributeKit & SetFont(char const * in_name);
14242 
14246  TextAttributeKit & SetTransform(Text::Transform in_trans);
14247 
14251  TextAttributeKit & SetRenderer(Text::Renderer in_rend);
14252 
14257  TextAttributeKit & SetPreference(Text::Preference in_pref);
14258 
14266  TextAttributeKit & SetPreference(float in_cutoff, Text::SizeUnits in_units, Text::Preference in_smaller, Text::Preference in_larger);
14267 
14272  TextAttributeKit & SetPath(Vector const & in_path);
14273 
14281  TextAttributeKit & SetSpacing(float in_multiplier);
14282 
14287  TextAttributeKit & SetBackground(bool in_state, char const * in_name);
14288 
14293  TextAttributeKit & SetBackground(char const * in_name);
14294 
14298  TextAttributeKit & SetBackground(bool in_state);
14299 
14304  TextAttributeKit & SetBackgroundMargins(float in_size, Text::MarginUnits in_units = Text::MarginUnits::Percent);
14305 
14311  TextAttributeKit & SetBackgroundMargins(FloatArray const & in_sizes, TextMarginUnitsArray const & in_units);
14312 
14319  TextAttributeKit & SetBackgroundMargins(size_t in_count, float const in_sizes [], HPS::Text::MarginUnits const in_units []);
14320 
14325  TextAttributeKit & SetBackgroundStyle(char const * in_name);
14326 
14327 
14330  TextAttributeKit & UnsetAlignment();
14331 
14334  TextAttributeKit & UnsetBold();
14335 
14338  TextAttributeKit & UnsetItalic();
14339 
14342  TextAttributeKit & UnsetOverline();
14343 
14346  TextAttributeKit & UnsetStrikethrough();
14347 
14350  TextAttributeKit & UnsetUnderline();
14351 
14354  TextAttributeKit & UnsetSlant();
14355 
14358  TextAttributeKit & UnsetLineSpacing();
14359 
14362  TextAttributeKit & UnsetRotation();
14363 
14366  TextAttributeKit & UnsetExtraSpace();
14367 
14370  TextAttributeKit & UnsetGreeking();
14371 
14374  TextAttributeKit & UnsetSizeTolerance();
14375 
14378  TextAttributeKit & UnsetSize();
14379 
14382  TextAttributeKit & UnsetFont();
14383 
14386  TextAttributeKit & UnsetTransform();
14387 
14390  TextAttributeKit & UnsetRenderer();
14391 
14394  TextAttributeKit & UnsetPreference();
14395 
14398  TextAttributeKit & UnsetPath();
14399 
14402  TextAttributeKit & UnsetSpacing();
14403 
14406  TextAttributeKit & UnsetBackground();
14407 
14410  TextAttributeKit & UnsetBackgroundMargins();
14411 
14414  TextAttributeKit & UnsetBackgroundStyle();
14415 
14418  TextAttributeKit & UnsetEverything();
14419 
14420 
14426  bool ShowAlignment(Text::Alignment & out_align, Text::ReferenceFrame & out_ref, Text::Justification & out_justify) const;
14427 
14431  bool ShowBold(bool & out_state) const;
14432 
14436  bool ShowItalic(bool & out_state) const;
14437 
14441  bool ShowOverline(bool & out_state) const;
14442 
14446  bool ShowStrikethrough(bool & out_state) const;
14447 
14451  bool ShowUnderline(bool & out_state) const;
14452 
14456  bool ShowSlant(float & out_angle) const;
14457 
14461  bool ShowLineSpacing(float & out_multiplier) const;
14462 
14467  bool ShowRotation(Text::Rotation & out_rot, float & out_angle) const;
14468 
14474  bool ShowExtraSpace(bool & out_state, float & out_size, Text::SizeUnits & out_units) const;
14475 
14482  bool ShowGreeking(bool & out_state, float & out_size, Text::GreekingUnits & out_units, Text::GreekingMode & out_mode) const;
14483 
14489  bool ShowSizeTolerance(bool & out_state, float & out_size, Text::SizeToleranceUnits & out_units) const;
14490 
14495  bool ShowSize(float & out_size, Text::SizeUnits & out_units) const;
14496 
14500  bool ShowFont(UTF8 & out_name) const;
14501 
14505  bool ShowTransform(Text::Transform & out_trans) const;
14506 
14510  bool ShowRenderer(Text::Renderer & out_rend) const;
14511 
14518  bool ShowPreference(float & out_cutoff, Text::SizeUnits & out_units, Text::Preference & out_smaller, Text::Preference & out_larger) const;
14519 
14523  bool ShowPath(Vector & out_path) const;
14524 
14528  bool ShowSpacing(float & out_multiplier) const;
14529 
14534  bool ShowBackground(bool & out_state, UTF8 & out_name) const;
14535 
14540  bool ShowBackgroundMargins(FloatArray & out_size, TextMarginUnitsArray & out_units) const;
14541 
14545  bool ShowBackgroundStyle(UTF8 & out_name) const;
14546 };
14547 
14553 class HPS_API TextAttributeControl : public Control
14554 {
14555 public:
14556 
14558  explicit TextAttributeControl(SegmentKey & in_seg);
14559 
14561  TextAttributeControl(TextAttributeControl const & in_that);
14562 
14567 
14571  TextAttributeControl & operator=(TextAttributeControl && in_that);
14572 
14575 
14576  virtual HPS::Type Type() const { return ObjectType(); }
14577 
14578  static const HPS::Type staticType = HPS::Type::TextAttributeControl;
14579  HPS::Type ObjectType() const {return staticType;};
14580 
14584  TextAttributeControl & operator=(TextAttributeControl const & in_that);
14585 
14592 
14597  TextAttributeControl & SetBold(bool in_state);
14598 
14603  TextAttributeControl & SetItalic(bool in_state);
14604 
14608  TextAttributeControl & SetOverline(bool in_state);
14609 
14613  TextAttributeControl & SetStrikethrough(bool in_state);
14614 
14618  TextAttributeControl & SetUnderline(bool in_state);
14619 
14625  TextAttributeControl & SetSlant(float in_angle);
14626 
14631  TextAttributeControl & SetLineSpacing(float in_multiplier);
14632 
14637  TextAttributeControl & SetRotation(Text::Rotation in_state, float in_angle = 0.0f);
14638 
14643  TextAttributeControl & SetRotation(float in_angle);
14644 
14650  TextAttributeControl & SetExtraSpace(bool in_state, float in_size = 0.0f, Text::SizeUnits in_units = Text::SizeUnits::ObjectSpace);
14651 
14657  TextAttributeControl & SetExtraSpace(float in_size, Text::SizeUnits in_units);
14658 
14665  TextAttributeControl & SetGreeking(bool in_state, float in_size = 0.0f, Text::GreekingUnits in_units = Text::GreekingUnits::ObjectSpace, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
14666 
14673 
14683  TextAttributeControl & SetSizeTolerance(bool in_state, float in_size = 50.0f, Text::SizeToleranceUnits in_units = Text::SizeToleranceUnits::Percent);
14684 
14694  TextAttributeControl & SetSizeTolerance(float in_size, Text::SizeToleranceUnits in_units);
14695 
14700  TextAttributeControl & SetSize(float in_size, Text::SizeUnits in_units);
14701 
14708  TextAttributeControl & SetFont(char const * in_name);
14709 
14713  TextAttributeControl & SetTransform(Text::Transform in_trans);
14714 
14718  TextAttributeControl & SetRenderer(Text::Renderer in_rend);
14719 
14724  TextAttributeControl & SetPreference(Text::Preference in_pref);
14725 
14733  TextAttributeControl & SetPreference(float in_cutoff, Text::SizeUnits in_units, Text::Preference in_smaller, Text::Preference in_larger);
14734 
14739  TextAttributeControl & SetPath(Vector const & in_path);
14740 
14748  TextAttributeControl & SetSpacing(float in_multiplier);
14749 
14754  TextAttributeControl & SetBackground(bool in_state, char const * in_name);
14755 
14760  TextAttributeControl & SetBackground(char const * in_name);
14761 
14765  TextAttributeControl & SetBackground(bool in_state);
14766 
14771  TextAttributeControl & SetBackgroundMargins(float in_size, Text::MarginUnits in_units = Text::MarginUnits::Percent);
14772 
14778  TextAttributeControl & SetBackgroundMargins(FloatArray const & in_size, TextMarginUnitsArray const & in_units);
14779 
14786  TextAttributeControl & SetBackgroundMargins(size_t in_count, float const in_sizes [], HPS::Text::MarginUnits const in_units []);
14787 
14792  TextAttributeControl & SetBackgroundStyle(char const * in_name);
14793 
14794 
14798  TextAttributeControl & UnsetAlignment();
14799 
14803  TextAttributeControl & UnsetBold();
14804 
14808  TextAttributeControl & UnsetItalic();
14809 
14813  TextAttributeControl & UnsetOverline();
14814 
14818  TextAttributeControl & UnsetStrikethrough();
14819 
14823  TextAttributeControl & UnsetUnderline();
14824 
14828  TextAttributeControl & UnsetSlant();
14829 
14833  TextAttributeControl & UnsetLineSpacing();
14834 
14838  TextAttributeControl & UnsetRotation();
14839 
14843  TextAttributeControl & UnsetExtraSpace();
14844 
14848  TextAttributeControl & UnsetGreeking();
14849 
14853  TextAttributeControl & UnsetSizeTolerance();
14854 
14858  TextAttributeControl & UnsetSize();
14859 
14863  TextAttributeControl & UnsetFont();
14864 
14868  TextAttributeControl & UnsetTransform();
14869 
14873  TextAttributeControl & UnsetRenderer();
14874 
14878  TextAttributeControl & UnsetPreference();
14879 
14883  TextAttributeControl & UnsetPath();
14884 
14888  TextAttributeControl & UnsetSpacing();
14889 
14893  TextAttributeControl & UnsetBackground();
14894 
14898  TextAttributeControl & UnsetBackgroundMargins();
14899 
14903  TextAttributeControl & UnsetBackgroundStyle();
14904 
14908  TextAttributeControl & UnsetEverything();
14909 
14910 
14916  bool ShowAlignment(Text::Alignment & out_align, Text::ReferenceFrame & out_ref, Text::Justification & out_justify) const;
14917 
14921  bool ShowBold(bool & out_state) const;
14922 
14926  bool ShowItalic(bool & out_state) const;
14927 
14931  bool ShowOverline(bool & out_state) const;
14932 
14936  bool ShowStrikethrough(bool & out_state) const;
14937 
14941  bool ShowUnderline(bool & out_state) const;
14942 
14946  bool ShowSlant(float & out_angle) const;
14947 
14951  bool ShowLineSpacing(float & out_multiplier) const;
14952 
14957  bool ShowRotation(Text::Rotation & out_rot, float & out_angle) const;
14958 
14964  bool ShowExtraSpace(bool & out_state, float & out_size, Text::SizeUnits & out_units) const;
14965 
14972  bool ShowGreeking(bool & out_state, float & out_size, Text::GreekingUnits & out_units, Text::GreekingMode & out_mode) const;
14973 
14979  bool ShowSizeTolerance(bool & out_state, float & out_size, Text::SizeToleranceUnits & out_units) const;
14980 
14985  bool ShowSize(float & out_size, Text::SizeUnits & out_units) const;
14986 
14990  bool ShowFont(UTF8 & out_name) const;
14991 
14995  bool ShowTransform(Text::Transform & out_trans) const;
14996 
15000  bool ShowRenderer(Text::Renderer & out_rend) const;
15001 
15008  bool ShowPreference(float & out_cutoff, Text::SizeUnits & out_units, Text::Preference & out_smaller, Text::Preference & out_larger) const;
15009 
15013  bool ShowPath(Vector & out_path) const;
15014 
15018  bool ShowSpacing(float & out_multiplier) const;
15019 
15024  bool ShowBackground(bool & out_state, UTF8 & out_name) const;
15025 
15030  bool ShowBackgroundMargins(FloatArray & out_size, TextMarginUnitsArray & out_units) const;
15031 
15035  bool ShowBackgroundStyle(UTF8 & out_name) const;
15036 
15037 private:
15040 };
15041 
15042 
15043 
15044 
15045 
15047 class HPS_API LineAttributeKit : public Kit
15048 {
15049 public:
15050 
15052  LineAttributeKit();
15053 
15056  LineAttributeKit(LineAttributeKit const & in_kit);
15057 
15061  LineAttributeKit(LineAttributeKit && in_that);
15062 
15066  LineAttributeKit & operator=(LineAttributeKit && in_that);
15067 
15069  virtual ~LineAttributeKit();
15070 
15071  static const HPS::Type staticType = HPS::Type::LineAttributeKit;
15072  HPS::Type ObjectType() const {return staticType;};
15073 
15077  static LineAttributeKit GetDefault();
15078 
15081  void Set(LineAttributeKit const & in_kit);
15082 
15085  void Show(LineAttributeKit & out_kit) const;
15086 
15090  LineAttributeKit & operator=(LineAttributeKit const & in_kit);
15091 
15094  bool Empty() const;
15095 
15099  bool Equals(LineAttributeKit const & in_kit) const;
15100 
15104  bool operator==(LineAttributeKit const & in_kit) const;
15105 
15109  bool operator!=(LineAttributeKit const & in_kit) const;
15110 
15111 
15116  LineAttributeKit & SetPattern(char const * in_name);
15117 
15123  LineAttributeKit & SetPattern(char const * in_name, LinePatternOptionsKit const & in_options);
15124 
15129  LineAttributeKit & SetWeight(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
15130 
15131 
15134  LineAttributeKit & UnsetPattern();
15135 
15138  LineAttributeKit & UnsetWeight();
15139 
15142  LineAttributeKit & UnsetEverything();
15143 
15144 
15149  bool ShowPattern(UTF8 & out_pattern, LinePatternOptionsKit & out_options) const;
15150 
15155  bool ShowWeight(float & out_weight, Line::SizeUnits & out_units) const;
15156 };
15157 
15163 class HPS_API LineAttributeControl : public Control
15164 {
15165 public:
15166 
15168  explicit LineAttributeControl(SegmentKey & in_seg);
15169 
15171  LineAttributeControl(LineAttributeControl const & in_that);
15172 
15177 
15181  LineAttributeControl & operator=(LineAttributeControl && in_that);
15182 
15185 
15186  virtual HPS::Type Type() const { return ObjectType(); }
15187 
15188  static const HPS::Type staticType = HPS::Type::LineAttributeControl;
15189  HPS::Type ObjectType() const {return staticType;};
15190 
15194  LineAttributeControl & operator=(LineAttributeControl const & in_that);
15195 
15200  LineAttributeControl & SetPattern(char const * in_pattern);
15201 
15207  LineAttributeControl & SetPattern(char const * in_pattern, LinePatternOptionsKit const & in_options);
15208 
15213  LineAttributeControl & SetWeight(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
15214 
15215 
15219  LineAttributeControl & UnsetPattern();
15220 
15224  LineAttributeControl & UnsetWeight();
15225 
15229  LineAttributeControl & UnsetEverything();
15230 
15231 
15236  bool ShowPattern(UTF8 & out_pattern, LinePatternOptionsKit & out_options) const;
15237 
15242  bool ShowWeight(float & out_weight, Line::SizeUnits & out_units) const;
15243 
15244 private:
15247 };
15248 
15249 
15250 
15252 class HPS_API EdgeAttributeKit : public Kit
15253 {
15254 public:
15255 
15257  EdgeAttributeKit();
15258 
15261  EdgeAttributeKit(EdgeAttributeKit const & in_kit);
15262 
15266  EdgeAttributeKit(EdgeAttributeKit && in_that);
15267 
15271  EdgeAttributeKit & operator=(EdgeAttributeKit && in_that);
15272 
15274  virtual ~EdgeAttributeKit();
15275 
15276  static const HPS::Type staticType = HPS::Type::EdgeAttributeKit;
15277  HPS::Type ObjectType() const {return staticType;};
15278 
15282  static EdgeAttributeKit GetDefault();
15283 
15286  void Set(EdgeAttributeKit const & in_kit);
15287 
15290  void Show(EdgeAttributeKit & out_kit) const;
15291 
15295  EdgeAttributeKit & operator=(EdgeAttributeKit const & in_kit);
15296 
15299  bool Empty() const;
15300 
15304  bool Equals(EdgeAttributeKit const & in_kit) const;
15305 
15309  bool operator==(EdgeAttributeKit const & in_kit) const;
15310 
15314  bool operator!=(EdgeAttributeKit const & in_kit) const;
15315 
15316 
15321  EdgeAttributeKit & SetPattern(char const * in_pattern_name);
15322 
15327  EdgeAttributeKit & SetWeight(float in_weight, Edge::SizeUnits in_units = Edge::SizeUnits::ScaleFactor);
15328 
15332  EdgeAttributeKit & SetHardAngle(float in_angle);
15333 
15334 
15337  EdgeAttributeKit & UnsetPattern();
15338 
15341  EdgeAttributeKit & UnsetWeight();
15342 
15345  EdgeAttributeKit & UnsetHardAngle();
15346 
15349  EdgeAttributeKit & UnsetEverything();
15350 
15351 
15355  bool ShowPattern(UTF8 & out_pattern_name) const;
15356 
15361  bool ShowWeight(float & out_weight, Edge::SizeUnits & out_units) const;
15362 
15366  bool ShowHardAngle(float & out_angle) const;
15367 
15368 };
15369 
15375 class HPS_API EdgeAttributeControl : public Control
15376 {
15377 public:
15378 
15380  explicit EdgeAttributeControl(SegmentKey & in_seg);
15381 
15383  EdgeAttributeControl(EdgeAttributeControl const & in_that);
15384 
15389 
15393  EdgeAttributeControl & operator=(EdgeAttributeControl && in_that);
15394 
15397 
15398  virtual HPS::Type Type() const { return ObjectType(); }
15399 
15400  static const HPS::Type staticType = HPS::Type::EdgeAttributeControl;
15401  HPS::Type ObjectType() const {return staticType;};
15402 
15406  EdgeAttributeControl & operator=(EdgeAttributeControl const & in_that);
15407 
15412  EdgeAttributeControl & SetPattern(char const * in_pattern_name);
15413 
15418  EdgeAttributeControl & SetWeight(float in_weight, Edge::SizeUnits in_units = Edge::SizeUnits::ScaleFactor);
15419 
15423  EdgeAttributeControl & SetHardAngle(float in_angle);
15424 
15425 
15429  EdgeAttributeControl & UnsetPattern();
15430 
15434  EdgeAttributeControl & UnsetWeight();
15435 
15439  EdgeAttributeControl & UnsetHardAngle();
15440 
15444  EdgeAttributeControl & UnsetEverything();
15445 
15446 
15450  bool ShowPattern(UTF8 & out_pattern_name) const;
15451 
15456  bool ShowWeight(float & out_weight, Edge::SizeUnits & out_units) const;
15457 
15461  bool ShowHardAngle(float & out_angle) const;
15462 
15463 private:
15466 };
15467 
15468 
15470 class HPS_API CurveAttributeKit : public Kit
15471 {
15472 public:
15473 
15476 
15479  CurveAttributeKit(CurveAttributeKit const & in_kit);
15480 
15485 
15489  CurveAttributeKit & operator=(CurveAttributeKit && in_that);
15490 
15492  virtual ~CurveAttributeKit();
15493 
15494  static const HPS::Type staticType = HPS::Type::CurveAttributeKit;
15495  HPS::Type ObjectType() const {return staticType;};
15496 
15500  static CurveAttributeKit GetDefault();
15501 
15504  void Set(CurveAttributeKit const & in_kit);
15505 
15508  void Show(CurveAttributeKit & out_kit) const;
15509 
15513  CurveAttributeKit & operator=(CurveAttributeKit const & in_kit);
15514 
15517  bool Empty() const;
15518 
15522  bool Equals(CurveAttributeKit const & in_kit) const;
15523 
15527  bool operator==(CurveAttributeKit const & in_kit) const;
15528 
15532  bool operator!=(CurveAttributeKit const & in_kit) const;
15533 
15534  //Set
15535  CurveAttributeKit & SetBudget(size_t in_budget);
15536 
15543  CurveAttributeKit & SetContinuedBudget(bool in_state, size_t in_budget = 0);
15544 
15551  CurveAttributeKit & SetContinuedBudget(size_t in_budget);
15552 
15553 
15560  CurveAttributeKit & SetViewDependent(bool in_state);
15561 
15565  CurveAttributeKit & SetMaximumDeviation(float in_deviation);
15566 
15571  CurveAttributeKit & SetMaximumAngle(float in_degrees);
15572 
15577  CurveAttributeKit & SetMaximumLength(float in_length);
15578 
15579 
15582  CurveAttributeKit & UnsetBudget();
15583 
15586  CurveAttributeKit & UnsetContinuedBudget();
15587 
15590  CurveAttributeKit & UnsetViewDependent();
15591 
15594  CurveAttributeKit & UnsetMaximumDeviation();
15595 
15598  CurveAttributeKit & UnsetMaximumAngle();
15599 
15602  CurveAttributeKit & UnsetMaximumLength();
15603 
15606  CurveAttributeKit & UnsetEverything();
15607 
15608 
15612  bool ShowBudget(size_t & out_budget) const;
15613 
15618  bool ShowContinuedBudget(bool & out_state, size_t & out_budget) const;
15619 
15623  bool ShowViewDependent(bool & out_state) const;
15624 
15629  bool ShowMaximumDeviation(float & out_deviation) const;
15630 
15635  bool ShowMaximumAngle(float & out_degrees) const;
15636 
15641  bool ShowMaximumLength(float & out_length) const;
15642 };
15643 
15644 
15648 class HPS_API CurveAttributeControl : public Control
15649 {
15650 public:
15651 
15653  explicit CurveAttributeControl(SegmentKey & in_seg);
15654 
15657 
15662 
15666  CurveAttributeControl & operator=(CurveAttributeControl && in_that);
15667 
15670 
15671  virtual HPS::Type Type() const { return ObjectType(); }
15672 
15673  static const HPS::Type staticType = HPS::Type::CurveAttributeControl;
15674  HPS::Type ObjectType() const {return staticType;};
15675 
15679  CurveAttributeControl & operator=(CurveAttributeControl const & in_that);
15680 
15684  CurveAttributeControl & SetBudget(size_t in_budget);
15685 
15692  CurveAttributeControl & SetContinuedBudget(bool in_state, size_t in_budget = 0);
15693 
15700  CurveAttributeControl & SetContinuedBudget(size_t in_budget);
15701 
15708  CurveAttributeControl & SetViewDependent(bool in_state);
15709 
15713  CurveAttributeControl & SetMaximumDeviation(float in_deviation);
15714 
15719  CurveAttributeControl & SetMaximumAngle(float in_degrees);
15720 
15725  CurveAttributeControl & SetMaximumLength(float in_length);
15726 
15727 
15731  CurveAttributeControl & UnsetBudget();
15732 
15736  CurveAttributeControl & UnsetContinuedBudget();
15737 
15741  CurveAttributeControl & UnsetViewDependent();
15742 
15746  CurveAttributeControl & UnsetMaximumDeviation();
15747 
15751  CurveAttributeControl & UnsetMaximumAngle();
15752 
15756  CurveAttributeControl & UnsetMaximumLength();
15757 
15761  CurveAttributeControl & UnsetEverything();
15762 
15763 
15767  bool ShowBudget(size_t & out_budget) const;
15768 
15773  bool ShowContinuedBudget(bool & out_state, size_t & out_budget) const;
15774 
15778  bool ShowViewDependent(bool & out_state) const;
15779 
15784  bool ShowMaximumDeviation(float & out_deviation) const;
15785 
15790  bool ShowMaximumAngle(float & out_degrees) const;
15791 
15796  bool ShowMaximumLength(float & out_length) const;
15797 
15798 private:
15801 };
15802 
15804 class HPS_API MatrixKit
15805 {
15806 public:
15807  float data[16];
15808 
15810  MatrixKit();
15811 
15814  MatrixKit(MatrixKit const & in_other);
15815 
15819  MatrixKit(FloatArray const & in_matrix_source);
15820 
15824  MatrixKit(float const in_matrix_source[]);
15825 
15828  MatrixKit(Quaternion const & in_quaternion); //implicit conversion from quaternion
15829 
15831  virtual ~MatrixKit();
15832 
15835  static MatrixKit GetDefault();
15836 
15840  bool Equals(MatrixKit const & in_kit) const;
15841 
15845  bool operator==(MatrixKit const & in_kit) const;
15846 
15850  bool operator!=(MatrixKit const & in_kit) const;
15851 
15855  bool ShowDeterminant(float & out_determinant) const;
15856 
15860  bool ShowInverse(MatrixKit & out_matrix) const;
15861 
15866  bool ShowAdjoint(MatrixKit & out_matrix) const;
15867 
15871  MatrixKit & UnsetEverything();
15872 
15874  void Reset();
15875 
15879  bool Empty() const;
15880 
15883  void Set(MatrixKit const & other);
15884 
15890  bool ShowElement(size_t in_row, size_t in_column, float & out_value) const;
15891 
15896  bool ShowElement(size_t in_ordinal_zero_to_fifteen, float & out_value) const;
15897 
15901  bool ShowElements(FloatArray & out_matrix) const;
15902 
15903 #ifndef HPS_GULP_CLANG
15904 
15907  bool ShowElements(float out_matrix[]) const;
15908 #endif
15909 
15915  MatrixKit & Rotate(float in_x, float in_y, float in_z);
15916 
15921  MatrixKit & RotateOffAxis(Vector const & in_vector, float in_theta);
15922 
15928  MatrixKit & Translate(float in_x, float in_y, float in_z);
15929 
15933  MatrixKit & Translate(Vector const & in_translation);
15934 
15940  MatrixKit & Scale(float in_x, float in_y, float in_z);
15941 
15945  MatrixKit & Concatenate(MatrixKit const & in_kit);
15946 
15949  MatrixKit & Normalize();
15950 
15953  MatrixKit & Invert();
15954 
15958  MatrixKit & Adjoint();
15959 
15962  bool IsIdentity() const;
15963 
15967  MatrixKit Multiply(MatrixKit const & in_right) const;
15968 
15972  MatrixKit & MultiplyAndAssign(MatrixKit const & in_right);
15973 
15977  MatrixKit Multiply(float in_scalar) const;
15978 
15982  MatrixKit & MultiplyAndAssign(float in_scalar);
15983 
15989  MatrixKit & SetElement(size_t in_row, size_t in_column, float in_value);
15990 
15995  MatrixKit & SetElement(size_t in_ordinal_zero_to_fifteen, float in_value);
15996 
16000  MatrixKit & SetElements(FloatArray const & in_values);
16001 
16006  MatrixKit & SetElements(size_t in_value_count, float const in_values[]);
16007 
16011  Point Transform(Point const & in_source) const;
16012 
16016  PointArray Transform(PointArray const & in_source) const;
16017 
16022  PointArray Transform(size_t in_count, Point const in_source[]) const;
16023 
16027  Vector Transform(Vector const & in_source) const;
16028 
16032  VectorArray Transform(VectorArray const & in_source) const;
16033 
16038  VectorArray Transform(size_t in_count, Vector const in_source[]) const;
16039 
16043  Plane Transform(Plane const & in_source) const;
16044 
16048  PlaneArray Transform(PlaneArray const & in_source) const;
16049 
16054  PlaneArray Transform(size_t in_count, Plane const in_source[]) const;
16055 
16059  SimpleCuboid Transform(SimpleCuboid const & in_source) const;
16060 
16064  SimpleSphere Transform(SimpleSphere const & in_source) const;
16065 
16069  MatrixKit & operator=(MatrixKit const & in_kit);
16070 
16074  MatrixKit operator*(MatrixKit const & in_right) const;
16075 
16079  MatrixKit const & operator*=(MatrixKit const & in_right);
16080 
16084  MatrixKit operator*(float in_scalar) const;
16085 
16089  MatrixKit const & operator*=(float in_scalar);
16090 };
16091 
16095 class HPS_API ModellingMatrixControl : public Control
16096 {
16097 public:
16098 
16100  explicit ModellingMatrixControl(SegmentKey const & in_seg);
16101 
16103  explicit ModellingMatrixControl(ReferenceKey const & in_ref);
16104 
16107 
16112 
16116  ModellingMatrixControl & operator=(ModellingMatrixControl && in_that);
16117 
16120 
16121  virtual HPS::Type Type() const { return ObjectType(); }
16122 
16123  static const HPS::Type staticType = HPS::Type::ModellingMatrixControl;
16124  HPS::Type ObjectType() const {return staticType;};
16125 
16129  ModellingMatrixControl & operator=(ModellingMatrixControl const & in_that);
16130 
16133  ModellingMatrixControl & Set(MatrixKit const & in_matrix);
16134 
16140  ModellingMatrixControl & SetElement(size_t in_row, size_t in_column, float in_value);
16141 
16146  ModellingMatrixControl & SetElement(size_t in_ordinal_zero_to_fifteen, float in_value);
16147 
16151  ModellingMatrixControl & SetElements(FloatArray const & in_values);
16152 
16157  ModellingMatrixControl & SetElements(size_t in_value_count, float const in_values []);
16158 
16159 
16162  ModellingMatrixControl & UnsetEverything();
16163 
16166  bool Show(MatrixKit & out_matrix) const;
16167 
16173  bool ShowElement(size_t in_row, size_t in_column, float & out_value) const;
16174 
16179  bool ShowElement(size_t in_ordinal_zero_to_fifteen, float & out_value) const;
16180 
16184  bool ShowElements(FloatArray & out_matrix) const;
16185 
16189  bool ShowDeterminant(float & out_determinant) const;
16190 
16194  bool ShowInverse(MatrixKit & out_matrix) const;
16195 
16200  bool ShowAdjoint(MatrixKit & out_matrix) const;
16201 
16207  ModellingMatrixControl & Rotate(float in_x, float in_y, float in_z);
16208 
16213  ModellingMatrixControl & RotateOffAxis(Vector const & in_vector, float in_theta);
16214 
16220  ModellingMatrixControl & Translate(float in_x, float in_y, float in_z);
16221 
16225  ModellingMatrixControl & Translate(Vector const & in_translation);
16226 
16232  ModellingMatrixControl & Scale(float in_x, float in_y, float in_z);
16233 
16237  ModellingMatrixControl & Concatenate(MatrixKit const & in_kit);
16238 
16241  ModellingMatrixControl & Normalize();
16242 
16245  ModellingMatrixControl & Invert();
16246 
16250  ModellingMatrixControl & Adjoint();
16251 
16252 private:
16255 };
16256 
16259 class HPS_API TextureMatrixControl : public Control
16260 {
16261 public:
16262 
16264  explicit TextureMatrixControl(SegmentKey & in_seg);
16265 
16267  TextureMatrixControl(const TextureMatrixControl & in_that);
16268 
16273 
16277  TextureMatrixControl & operator=(TextureMatrixControl && in_that);
16278 
16281 
16282  virtual HPS::Type Type() const { return ObjectType(); }
16283 
16284  static const HPS::Type staticType = HPS::Type::TextureMatrixControl;
16285  HPS::Type ObjectType() const {return staticType;};
16286 
16290  TextureMatrixControl & operator=(TextureMatrixControl const & in_that);
16291 
16294  TextureMatrixControl & Set(MatrixKit const & in_matrix);
16295 
16301  TextureMatrixControl & SetElement(size_t in_row, size_t in_column, float in_value);
16302 
16307  TextureMatrixControl & SetElement(size_t in_ordinal_zero_to_fifteen, float in_value);
16308 
16312  TextureMatrixControl & SetElements(FloatArray const & in_values);
16313 
16318  TextureMatrixControl & SetElements(size_t in_value_count, float const in_values []);
16319 
16320 
16323  TextureMatrixControl & UnsetEverything();
16324 
16325 
16328  bool Show(MatrixKit & out_matrix) const;
16329 
16335  bool ShowElement(size_t in_row, size_t in_column, float & out_value) const;
16336 
16341  bool ShowElement(size_t in_ordinal_zero_to_fifteen, float & out_value) const;
16342 
16346  bool ShowElements(FloatArray & out_matrix) const;
16347 
16351  bool ShowDeterminant(float & out_determinant) const;
16352 
16356  bool ShowInverse(MatrixKit & out_matrix) const;
16357 
16362  bool ShowAdjoint(MatrixKit & out_matrix) const;
16363 
16369  TextureMatrixControl & Rotate(float in_x, float in_y, float in_z);
16370 
16375  TextureMatrixControl & RotateOffAxis(Vector const & in_vector, float in_theta);
16376 
16382  TextureMatrixControl & Translate(float in_x, float in_y, float in_z);
16383 
16389  TextureMatrixControl & Scale(float in_x, float in_y, float in_z);
16390 
16394  TextureMatrixControl & Concatenate(MatrixKit const & in_kit);
16395 
16398  TextureMatrixControl & Normalize();
16399 
16402  TextureMatrixControl & Invert();
16403 
16407  TextureMatrixControl & Adjoint();
16408 
16409 private:
16412 };
16413 
16414 
16417 class HPS_API MaterialMappingKit : public Kit
16418 {
16419 public:
16420 
16423 
16426  MaterialMappingKit(MaterialMappingKit const & in_kit);
16427 
16432 
16436  MaterialMappingKit & operator=(MaterialMappingKit && in_that);
16437 
16439  ~MaterialMappingKit();
16440 
16441  static const HPS::Type staticType = HPS::Type::MaterialMappingKit;
16442  HPS::Type ObjectType() const {return staticType;};
16443 
16447  static MaterialMappingKit GetDefault();
16448 
16451  void Set(MaterialMappingKit const & in_kit);
16452 
16455  void Show(MaterialMappingKit & out_kit) const;
16456 
16460  MaterialMappingKit & operator=(MaterialMappingKit const & in_kit);
16461 
16464  bool Empty() const;
16465 
16469  bool Equals(MaterialMappingKit const & in_kit) const;
16470 
16474  bool operator==(MaterialMappingKit const & in_kit) const;
16475 
16479  bool operator!=(MaterialMappingKit const & in_kit) const;
16480 
16481  //Set
16482 
16486  MaterialMappingKit & SetAmbientLightUpColor(RGBAColor const & in_rgba_color);
16487 
16493  MaterialMappingKit & SetAmbientLightUpMaterialByIndex(float in_material_index);
16494 
16495 
16499  MaterialMappingKit & SetAmbientLightDownColor(RGBAColor const & in_rgba_color);
16500 
16506  MaterialMappingKit & SetAmbientLightDownMaterialByIndex(float in_material_index);
16507 
16513  MaterialMappingKit & SetBackFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
16514 
16519  MaterialMappingKit & SetBackFaceAlpha(float in_alpha);
16520 
16527  MaterialMappingKit & SetBackFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
16528 
16537  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);
16538 
16542  MaterialMappingKit & SetBackFaceGloss(float in_value);
16543 
16547  MaterialMappingKit & SetBackFaceMaterial(MaterialKit const & in_material);
16548 
16553  MaterialMappingKit & SetBackFaceMaterialByIndex(float in_material_index);
16554 
16560  MaterialMappingKit & SetFrontFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
16561 
16566  MaterialMappingKit & SetFrontFaceAlpha(float in_alpha);
16567 
16574  MaterialMappingKit & SetFrontFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
16575 
16584  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);
16585 
16589  MaterialMappingKit & SetFrontFaceGloss(float in_value);
16590 
16594  MaterialMappingKit & SetFrontFaceMaterial(MaterialKit const & in_material);
16595 
16600  MaterialMappingKit & SetFrontFaceMaterialByIndex(float in_material_index);
16601 
16602 
16606  MaterialMappingKit & SetCutEdgeColor(RGBAColor const & in_rgba_color);
16607 
16613  MaterialMappingKit & SetCutEdgeMaterialByIndex(float in_material_index);
16614 
16620  MaterialMappingKit & SetCutFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
16621 
16626  MaterialMappingKit & SetCutFaceAlpha(float in_alpha);
16627 
16634  MaterialMappingKit & SetCutFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
16635 
16644  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);
16645 
16649  MaterialMappingKit & SetCutFaceGloss(float in_value);
16650 
16654  MaterialMappingKit & SetCutFaceMaterial(MaterialKit const & in_material);
16655 
16660  MaterialMappingKit & SetCutFaceMaterialByIndex(float in_material_index);
16661 
16666  MaterialMappingKit & SetEdgeAlpha(float in_alpha);
16667 
16673  MaterialMappingKit & SetEdgeColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
16674 
16681  MaterialMappingKit & SetEdgeTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
16682 
16691  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);
16692 
16696  MaterialMappingKit & SetEdgeGloss(float in_value);
16697 
16701  MaterialMappingKit & SetEdgeMaterial(MaterialKit const & in_material);
16702 
16707  MaterialMappingKit & SetEdgeMaterialByIndex(float in_material_index);
16708 
16713  MaterialMappingKit & SetFaceAlpha(float in_alpha);
16714 
16720  MaterialMappingKit & SetFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
16721 
16728  MaterialMappingKit & SetFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
16729 
16738  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);
16739 
16743  MaterialMappingKit & SetFaceGloss(float in_value);
16744 
16748  MaterialMappingKit & SetFaceMaterial(MaterialKit const & in_material);
16749 
16754  MaterialMappingKit & SetFaceMaterialByIndex(float in_material_index);
16755 
16759  MaterialMappingKit & SetFaceShader(char const * in_shader_name);
16760 
16761 
16762 
16763 
16764 
16768  MaterialMappingKit & SetLightColor(RGBAColor const & in_rgba_color);
16769 
16775  MaterialMappingKit & SetLightMaterialByIndex(float in_material_index);
16776 
16777 
16781  MaterialMappingKit & SetLineAlpha(float in_alpha);
16782 
16788  MaterialMappingKit & SetLineColor(RGBAColor const & in_rgba_color);
16789 
16795  MaterialMappingKit & SetLineMaterialByIndex(float in_material_index);
16796 
16797 
16801  MaterialMappingKit & SetMarkerColor(RGBAColor const & in_rgba_color);
16802 
16808  MaterialMappingKit & SetMarkerMaterialByIndex(float in_material_index);
16809 
16810 
16814  MaterialMappingKit & SetTextColor(RGBAColor const & in_rgba_color);
16815 
16821  MaterialMappingKit & SetTextMaterialByIndex(float in_material_index);
16822 
16827  MaterialMappingKit & SetVertexAlpha(float in_alpha);
16828 
16834  MaterialMappingKit & SetVertexColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
16835 
16842  MaterialMappingKit & SetVertexTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
16843 
16852  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);
16853 
16857  MaterialMappingKit & SetVertexGloss(float in_value);
16858 
16862  MaterialMappingKit & SetVertexMaterial(MaterialKit const & in_material);
16863 
16868  MaterialMappingKit & SetVertexMaterialByIndex(float in_material_index);
16869 
16873  MaterialMappingKit & SetVertexShader(char const * in_shader_name);
16874 
16875 
16879  MaterialMappingKit & SetWindowColor(RGBAColor const & in_rgba_color);
16880 
16886  MaterialMappingKit & SetWindowMaterialByIndex(float in_material_index);
16887 
16888 
16892  MaterialMappingKit & SetWindowContrastColor(RGBAColor const & in_rgba_color);
16893 
16899  MaterialMappingKit & SetWindowContrastMaterialByIndex(float in_material_index);
16900 
16901  //Aggregate Sets
16902 
16906  MaterialMappingKit & SetCutGeometryColor(RGBAColor const & in_rgba_color);
16907 
16912  MaterialMappingKit & SetCutGeometryMaterialByIndex(float in_color_index);
16913 
16914 
16918  MaterialMappingKit & SetAmbientLightColor(RGBAColor const & in_rgba_color);
16919 
16925  MaterialMappingKit & SetAmbientLightMaterialByIndex(float in_material_index);
16926 
16927  //Aggregate set
16928 
16932  MaterialMappingKit & SetGeometryColor(RGBAColor const & in_rgba_color);
16933 
16934  //Unset
16935 
16938  MaterialMappingKit & UnsetAmbientLightUpColor();
16939 
16940 
16943  MaterialMappingKit & UnsetAmbientLightDownColor();
16944 
16945 
16948  MaterialMappingKit & UnsetBackFaceMaterial();
16949 
16952  MaterialMappingKit & UnsetBackFaceChannel(Material::Channel in_channel);
16953 
16956  MaterialMappingKit & UnsetBackFaceChannel(Material::Channel in_channel, size_t in_layer);
16957 
16960  MaterialMappingKit & UnsetFrontFaceMaterial();
16961 
16964  MaterialMappingKit & UnsetFrontFaceChannel(Material::Channel in_channel);
16965 
16968  MaterialMappingKit & UnsetFrontFaceChannel(Material::Channel in_channel, size_t in_layer);
16969 
16970 
16971 
16974  MaterialMappingKit & UnsetCutEdgeColor();
16975 
16976 
16979  MaterialMappingKit & UnsetCutFaceMaterial();
16980 
16983  MaterialMappingKit & UnsetCutFaceChannel(Material::Channel in_channel);
16984 
16987  MaterialMappingKit & UnsetCutFaceChannel(Material::Channel in_channel, size_t in_layer);
16988 
16989 
16992  MaterialMappingKit & UnsetEdgeMaterial();
16993 
16996  MaterialMappingKit & UnsetEdgeChannel(Material::Channel in_channel);
16997 
17000  MaterialMappingKit & UnsetEdgeChannel(Material::Channel in_channel, size_t in_layer);
17001 
17002 
17005  MaterialMappingKit & UnsetFaceMaterial();
17006 
17009  MaterialMappingKit & UnsetFaceChannel(Material::Channel in_channel);
17010 
17013  MaterialMappingKit & UnsetFaceChannel(Material::Channel in_channel, size_t in_layer);
17014 
17015 
17018  MaterialMappingKit & UnsetLightColor();
17019 
17020 
17023  MaterialMappingKit & UnsetLineAlpha();
17024 
17028  MaterialMappingKit & UnsetLineColor();
17029 
17030 
17033  MaterialMappingKit & UnsetMarkerColor();
17034 
17035 
17038  MaterialMappingKit & UnsetTextColor();
17039 
17040 
17043  MaterialMappingKit & UnsetVertexMaterial();
17044 
17047  MaterialMappingKit & UnsetVertexChannel(Material::Channel in_channel);
17048 
17051  MaterialMappingKit & UnsetVertexChannel(Material::Channel in_channel, size_t in_layer);
17052 
17053 
17056  MaterialMappingKit & UnsetWindowColor();
17057 
17058 
17061  MaterialMappingKit & UnsetWindowContrastColor();
17062 
17063 
17064  //Aggregate Unsets
17065 
17068  MaterialMappingKit & UnsetCutGeometryColor();
17069 
17072  MaterialMappingKit & UnsetAmbientLightColor();
17073 
17076  MaterialMappingKit & UnsetEverything();
17077 
17078 
17079  //Show
17080 
17086  bool ShowAmbientLightUpColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
17087 
17093  bool ShowAmbientLightDownColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
17094 
17095 
17104  bool ShowBackFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
17105 
17115  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;
17116 
17122  bool ShowBackFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
17123 
17124 
17133  bool ShowFrontFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
17134 
17144  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;
17145 
17151  bool ShowFrontFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
17152 
17153 
17154 
17160  bool ShowCutEdgeColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
17161 
17162 
17170  bool ShowCutFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
17171 
17180  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;
17181 
17187  bool ShowCutFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
17188 
17189 
17197  bool ShowEdgeChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
17198 
17207  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;
17208 
17214  bool ShowEdgeMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
17215 
17216 
17225  bool ShowFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
17226 
17236  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;
17237 
17243  bool ShowFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
17244 
17245 
17251  bool ShowLightColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
17252 
17253 
17257  bool ShowLineAlpha(float & out_alpha) const;
17258 
17259 
17265  bool ShowLineColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
17266 
17267 
17273  bool ShowMarkerColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
17274 
17275 
17281  bool ShowTextColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
17282 
17283 
17291  bool ShowVertexChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
17292 
17301  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;
17302 
17308  bool ShowVertexMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
17309 
17310 
17316  bool ShowWindowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
17317 
17318 
17324  bool ShowWindowContrastColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
17325 };
17326 
17327 
17328 
17330 class HPS_API PBRMaterialKit : public Kit
17331 {
17332 public:
17333 
17335  PBRMaterialKit();
17336 
17339  PBRMaterialKit(PBRMaterialKit const & in_kit);
17340 
17344  PBRMaterialKit(PBRMaterialKit && in_that);
17345 
17349  PBRMaterialKit & operator=(PBRMaterialKit && in_that);
17350 
17352  ~PBRMaterialKit();
17353 
17354  static const HPS::Type staticType = HPS::Type::PBRMaterialKit;
17355  HPS::Type ObjectType() const { return staticType; };
17356 
17360  static PBRMaterialKit GetDefault();
17361 
17364  void Set(PBRMaterialKit const & in_kit);
17365 
17368  void Show(PBRMaterialKit & out_kit) const;
17369 
17373  PBRMaterialKit & operator=(PBRMaterialKit const & in_kit);
17374 
17377  bool Empty() const;
17378 
17382  bool Equals(PBRMaterialKit const & in_kit) const;
17383 
17387  bool operator==(PBRMaterialKit const & in_kit) const;
17388 
17392  bool operator!=(PBRMaterialKit const & in_kit) const;
17393 
17394  //Set
17395 
17399  PBRMaterialKit & SetBaseColorMap(char const * in_texture_name);
17400 
17404  PBRMaterialKit & SetNormalMap(char const * in_texture_name);
17405 
17409  PBRMaterialKit & SetEmissiveMap(char const * in_texture_name);
17410 
17415  PBRMaterialKit & SetMetalnessMap(char const * in_texture_name, HPS::Material::Texture::ChannelMapping in_channel = HPS::Material::Texture::ChannelMapping::Red);
17416 
17421  PBRMaterialKit & SetRoughnessMap(char const * in_texture_name, HPS::Material::Texture::ChannelMapping in_channel = HPS::Material::Texture::ChannelMapping::Green);
17422 
17427  PBRMaterialKit & SetOcclusionMap(char const * in_texture_name, HPS::Material::Texture::ChannelMapping in_channel = HPS::Material::Texture::ChannelMapping::Blue);
17428 
17432  PBRMaterialKit & SetBaseColorFactor(HPS::RGBAColor const & in_color);
17433 
17437  PBRMaterialKit & SetNormalFactor(float in_factor);
17438 
17442  PBRMaterialKit & SetMetalnessFactor(float in_factor);
17443 
17447  PBRMaterialKit & SetRoughnessFactor(float in_factor);
17448 
17452  PBRMaterialKit & SetOcclusionFactor(float in_factor);
17453 
17458  PBRMaterialKit & SetAlphaFactor(float in_factor, bool in_mask = false);
17459 
17460  //Unset
17463  PBRMaterialKit & UnsetBaseColorMap();
17464 
17467  PBRMaterialKit & UnsetNormalMap();
17468 
17471  PBRMaterialKit & UnsetEmissiveMap();
17472 
17475  PBRMaterialKit & UnsetMetalnessMap();
17476 
17479  PBRMaterialKit & UnsetRoughnessMap();
17480 
17483  PBRMaterialKit & UnsetOcclusionMap();
17484 
17487  PBRMaterialKit & UnsetBaseColorFactor();
17488 
17491  PBRMaterialKit & UnsetNormalFactor();
17492 
17495  PBRMaterialKit & UnsetMetalnessFactor();
17496 
17499  PBRMaterialKit & UnsetRoughnessFactor();
17500 
17503  PBRMaterialKit & UnsetOcclusionFactor();
17504 
17507  PBRMaterialKit & UnsetAlphaFactor();
17508 
17511  PBRMaterialKit & UnsetEverything();
17512 
17513  //Show
17514 
17518  bool ShowBaseColorMap(UTF8 & out_texture_name) const;
17519 
17523  bool ShowNormalMap(UTF8 & out_texture_name) const;
17524 
17528  bool ShowEmissiveMap(UTF8 & out_texture_name) const;
17529 
17534  bool ShowMetalnessMap(UTF8 & out_texture_name, HPS::Material::Texture::ChannelMapping & out_channel) const;
17535 
17540  bool ShowRoughnessMap(UTF8 & out_texture_name, HPS::Material::Texture::ChannelMapping & out_channel) const;
17541 
17546  bool ShowOcclusionMap(UTF8 & out_texture_name, HPS::Material::Texture::ChannelMapping & out_channel) const;
17547 
17551  bool ShowBaseColorFactor(HPS::RGBAColor & out_color) const;
17552 
17556  bool ShowNormalFactor(float & out_factor) const;
17557 
17561  bool ShowMetalnessFactor(float & out_factor) const;
17562 
17566  bool ShowRoughnessFactor(float & out_factor) const;
17567 
17571  bool ShowOcclusionFactor(float & out_factor) const;
17572 
17577  bool ShowAlphaFactor(float & out_factor, bool & out_mask) const;
17578 };
17579 
17580 
17586 class HPS_API MaterialMappingControl : public Control
17587 {
17588 public:
17589 
17591  explicit MaterialMappingControl(SegmentKey & in_seg);
17592 
17595 
17600 
17604  MaterialMappingControl & operator=(MaterialMappingControl && in_that);
17605 
17608 
17609  virtual HPS::Type Type() const { return ObjectType(); }
17610 
17611  static const HPS::Type staticType = HPS::Type::MaterialMappingControl;
17612  HPS::Type ObjectType() const {return staticType;};
17613 
17617  MaterialMappingControl & operator=(MaterialMappingControl const & in_that);
17618 
17619  //Set
17620 
17624  MaterialMappingControl & SetAmbientLightUpColor(RGBAColor const & in_rgba_color);
17625 
17631  MaterialMappingControl & SetAmbientLightUpMaterialByIndex(float in_material_index);
17632 
17633 
17637  MaterialMappingControl & SetAmbientLightDownColor(RGBAColor const & in_rgba_color);
17638 
17644  MaterialMappingControl & SetAmbientLightDownMaterialByIndex(float in_material_index);
17645 
17650  MaterialMappingControl & SetBackFaceAlpha(float in_alpha);
17651 
17657  MaterialMappingControl & SetBackFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
17658 
17665  MaterialMappingControl & SetBackFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
17666 
17675  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);
17676 
17680  MaterialMappingControl & SetBackFaceGloss(float in_value);
17681 
17685  MaterialMappingControl & SetBackFaceMaterial(MaterialKit const & in_material);
17686 
17691  MaterialMappingControl & SetBackFaceMaterialByIndex(float in_material_index);
17692 
17693 
17698  MaterialMappingControl & SetFrontFaceAlpha(float in_alpha);
17699 
17705  MaterialMappingControl & SetFrontFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
17706 
17713  MaterialMappingControl & SetFrontFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
17714 
17723  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);
17724 
17728  MaterialMappingControl & SetFrontFaceGloss(float in_value);
17729 
17733  MaterialMappingControl & SetFrontFaceMaterial(MaterialKit const & in_material);
17734 
17739  MaterialMappingControl & SetFrontFaceMaterialByIndex(float in_material_index);
17740 
17744  MaterialMappingControl & SetCutEdgeColor(RGBAColor const & in_rgba_color);
17745 
17751  MaterialMappingControl & SetCutEdgeMaterialByIndex(float in_material_index);
17752 
17757  MaterialMappingControl & SetCutFaceAlpha(float in_alpha);
17758 
17764  MaterialMappingControl & SetCutFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
17765 
17772  MaterialMappingControl & SetCutFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
17773 
17782  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);
17783 
17787  MaterialMappingControl & SetCutFaceGloss(float in_value);
17788 
17792  MaterialMappingControl & SetCutFaceMaterial(MaterialKit const & in_material);
17793 
17798  MaterialMappingControl & SetCutFaceMaterialByIndex(float in_material_index);
17799 
17804  MaterialMappingControl & SetEdgeAlpha(float in_alpha);
17805 
17811  MaterialMappingControl & SetEdgeColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
17812 
17819  MaterialMappingControl & SetEdgeTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
17820 
17829  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);
17830 
17834  MaterialMappingControl & SetEdgeGloss(float in_value);
17835 
17839  MaterialMappingControl & SetEdgeMaterial(MaterialKit const & in_material);
17840 
17845  MaterialMappingControl & SetEdgeMaterialByIndex(float in_material_index);
17846 
17852  MaterialMappingControl & SetFaceAlpha(float in_alpha);
17853 
17860  MaterialMappingControl & SetFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
17861 
17868  MaterialMappingControl & SetFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
17869 
17878  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);
17879 
17883  MaterialMappingControl & SetFaceGloss(float in_value);
17884 
17888  MaterialMappingControl & SetFaceMaterial(MaterialKit const & in_material);
17889 
17894  MaterialMappingControl & SetFaceMaterialByIndex(float in_material_index);
17895 
17899  MaterialMappingControl & SetFaceShader(char const * in_shader_name);
17900 
17901 
17905  MaterialMappingControl & SetLightColor(RGBAColor const & in_rgba_color);
17906 
17912  MaterialMappingControl & SetLightMaterialByIndex(float in_material_index);
17913 
17917  MaterialMappingControl & SetLineAlpha(float in_alpha);
17918 
17924  MaterialMappingControl & SetLineColor(RGBAColor const & in_rgba_color);
17925 
17931  MaterialMappingControl & SetLineMaterialByIndex(float in_material_index);
17932 
17933 
17937  MaterialMappingControl & SetMarkerColor(RGBAColor const & in_rgba_color);
17938 
17944  MaterialMappingControl & SetMarkerMaterialByIndex(float in_material_index);
17945 
17946 
17950  MaterialMappingControl & SetTextColor(RGBAColor const & in_rgba_color);
17951 
17957  MaterialMappingControl & SetTextMaterialByIndex(float in_material_index);
17958 
17959 
17964  MaterialMappingControl & SetVertexAlpha(float in_alpha);
17965 
17966 
17972  MaterialMappingControl & SetVertexColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
17973 
17980  MaterialMappingControl & SetVertexTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
17981 
17990  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);
17991 
17995  MaterialMappingControl & SetVertexGloss(float in_value);
17996 
18000  MaterialMappingControl & SetVertexMaterial(MaterialKit const & in_material);
18001 
18006  MaterialMappingControl & SetVertexMaterialByIndex(float in_material_index);
18007 
18011  MaterialMappingControl & SetVertexShader(char const * in_shader_name);
18012 
18013 
18017  MaterialMappingControl & SetWindowColor(RGBAColor const & in_rgba_color);
18018 
18024  MaterialMappingControl & SetWindowMaterialByIndex(float in_material_index);
18025 
18026 
18030  MaterialMappingControl & SetWindowContrastColor(RGBAColor const & in_rgba_color);
18031 
18037  MaterialMappingControl & SetWindowContrastMaterialByIndex(float in_material_index);
18038 
18039  //Aggregate Sets
18040 
18044  MaterialMappingControl & SetCutGeometryColor(RGBAColor const & in_rgba_color);
18045 
18050  MaterialMappingControl & SetCutGeometryMaterialByIndex(float in_color_index);
18051 
18052 
18056  MaterialMappingControl & SetAmbientLightColor(RGBAColor const & in_rgba_color);
18057 
18063  MaterialMappingControl & SetAmbientLightMaterialByIndex(float in_material_index);
18064 
18065 
18066  //Aggregate set
18067 
18071  MaterialMappingControl & SetGeometryColor(RGBAColor const & in_rgba_color);
18072 
18073 
18074  //Unset
18075 
18079  MaterialMappingControl & UnsetAmbientLightUpColor();
18080 
18081 
18085  MaterialMappingControl & UnsetAmbientLightDownColor();
18086 
18087 
18091  MaterialMappingControl & UnsetFrontFaceMaterial();
18092 
18096  MaterialMappingControl & UnsetFrontFaceChannel(Material::Channel in_channel);
18097 
18101  MaterialMappingControl & UnsetFrontFaceChannel(Material::Channel in_channel, size_t in_layer);
18102 
18103 
18107  MaterialMappingControl & UnsetBackFaceMaterial();
18108 
18112  MaterialMappingControl & UnsetBackFaceChannel(Material::Channel in_channel);
18113 
18117  MaterialMappingControl & UnsetBackFaceChannel(Material::Channel in_channel, size_t in_layer);
18118 
18119 
18123  MaterialMappingControl & UnsetCutEdgeColor();
18124 
18125 
18129  MaterialMappingControl & UnsetCutFaceMaterial();
18130 
18134  MaterialMappingControl & UnsetCutFaceChannel(Material::Channel in_channel);
18135 
18139  MaterialMappingControl & UnsetCutFaceChannel(Material::Channel in_channel, size_t in_layer);
18140 
18141 
18145  MaterialMappingControl & UnsetEdgeMaterial();
18146 
18150  MaterialMappingControl & UnsetEdgeChannel(Material::Channel in_channel);
18151 
18155  MaterialMappingControl & UnsetEdgeChannel(Material::Channel in_channel, size_t in_layer);
18156 
18157 
18161  MaterialMappingControl & UnsetFaceMaterial();
18162 
18166  MaterialMappingControl & UnsetFaceChannel(Material::Channel in_channel);
18167 
18171  MaterialMappingControl & UnsetFaceChannel(Material::Channel in_channel, size_t in_layer);
18172 
18173 
18177  MaterialMappingControl & UnsetLightColor();
18178 
18179 
18183  MaterialMappingControl & UnsetLineAlpha();
18184 
18189  MaterialMappingControl & UnsetLineColor();
18190 
18191 
18195  MaterialMappingControl & UnsetMarkerColor();
18196 
18197 
18201  MaterialMappingControl & UnsetTextColor();
18202 
18203 
18207  MaterialMappingControl & UnsetVertexMaterial();
18208 
18212  MaterialMappingControl & UnsetVertexChannel(Material::Channel in_channel);
18213 
18217  MaterialMappingControl & UnsetVertexChannel(Material::Channel in_channel, size_t in_layer);
18218 
18219 
18223  MaterialMappingControl & UnsetWindowColor();
18224 
18225 
18229  MaterialMappingControl & UnsetWindowContrastColor();
18230 
18231 
18232  //Aggregate Unsets
18233 
18237  MaterialMappingControl & UnsetCutGeometryColor();
18238 
18242  MaterialMappingControl & UnsetAmbientLightColor();
18243 
18247  MaterialMappingControl & UnsetEverything();
18248 
18249 
18250  //Show
18251 
18257  bool ShowAmbientLightUpColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
18258 
18259 
18265  bool ShowAmbientLightDownColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
18266 
18267 
18276  bool ShowBackFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
18277 
18287  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;
18288 
18294  bool ShowBackFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
18295 
18296 
18305  bool ShowFrontFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
18306 
18316  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;
18317 
18323  bool ShowFrontFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
18324 
18325 
18331  bool ShowCutEdgeColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
18332 
18333 
18341  bool ShowCutFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
18342 
18351  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;
18352 
18358  bool ShowCutFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
18359 
18360 
18368  bool ShowEdgeChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
18369 
18378  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;
18379 
18385  bool ShowEdgeMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
18386 
18387 
18396  bool ShowFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
18397 
18407  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;
18408 
18414  bool ShowFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
18415 
18416 
18422  bool ShowLightColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
18423 
18424 
18428  bool ShowLineAlpha(float & out_alpha) const;
18429 
18435  bool ShowLineColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
18436 
18437 
18443  bool ShowMarkerColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
18444 
18445 
18451  bool ShowTextColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
18452 
18453 
18461  bool ShowVertexChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
18462 
18471  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;
18472 
18478  bool ShowVertexMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
18479 
18480 
18486  bool ShowWindowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
18487 
18488 
18494  bool ShowWindowContrastColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
18495 
18496 private:
18498 };
18499 
18500 
18503 class HPS_API PortfolioControl : public Control
18504 {
18505 public:
18507  explicit PortfolioControl(SegmentKey & in_seg);
18508 
18510  PortfolioControl(PortfolioControl const & in_that);
18511 
18515  PortfolioControl(PortfolioControl && in_that);
18516 
18520  PortfolioControl & operator=(PortfolioControl && in_that);
18521 
18523  ~PortfolioControl();
18524 
18525  virtual HPS::Type Type() const { return ObjectType(); }
18526 
18527  static const HPS::Type staticType = HPS::Type::PortfolioControl;
18528  HPS::Type ObjectType() const { return staticType; };
18529 
18533  PortfolioControl & operator=(PortfolioControl const & in_that);
18534 
18536  size_t GetCount() const;
18537 
18538 
18543  PortfolioControl & Push(PortfolioKey const & in_portfolio);
18544 
18547  bool Pop();
18548 
18552  bool Pop(PortfolioKey & out_portfolio);
18553 
18554 
18558  PortfolioControl & Set(PortfolioKey const & in_portfolio);
18559 
18563  PortfolioControl & Set(PortfolioKeyArray const & in_portfolios);
18564 
18569  PortfolioControl & Set(size_t in_count, PortfolioKey const in_portfolios[]);
18570 
18571 
18574  PortfolioControl & UnsetTop();
18575 
18578  PortfolioControl & UnsetEverything();
18579 
18580 
18584  bool ShowTop(PortfolioKey & out_portfolio) const;
18585 
18589  bool Show(PortfolioKeyArray & out_portfolios) const;
18590 
18591 private:
18592  PortfolioControl();
18593 };
18594 
18595 
18596 
18599 class HPS_API StyleControl : public Control
18600 {
18601 public:
18603  explicit StyleControl(SegmentKey & in_seg);
18604 
18606  StyleControl(StyleControl const & in_that);
18607 
18611  StyleControl(StyleControl && in_that);
18612 
18616  StyleControl & operator=(StyleControl && in_that);
18617 
18619  ~StyleControl();
18620 
18621  virtual HPS::Type Type() const { return ObjectType(); }
18622 
18623  static const HPS::Type staticType = HPS::Type::StyleControl;
18624  HPS::Type ObjectType() const { return staticType; };
18625 
18629  StyleControl & operator=(StyleControl const & in_that);
18630 
18632  size_t GetCount() const;
18633 
18635  StyleKey PushNamed(char const * in_style_name);
18636 
18642  StyleKey PushNamed(char const * in_style_name, ConditionalExpression const & in_conditional);
18643 
18650  StyleKey AppendNamed(char const * in_style_name, ConditionalExpression const & in_conditional, Style::AppendMode in_mode = Style::AppendMode::Or);
18651 
18656  StyleKey PushSegment(SegmentKey const & in_style_source);
18657 
18663  StyleKey PushSegment(SegmentKey const & in_style_source, ConditionalExpression const & in_conditional);
18664 
18671  StyleKey AppendSegment(SegmentKey const & in_style_source, ConditionalExpression const & in_conditional, Style::AppendMode in_mode = Style::AppendMode::Or);
18672 
18673 
18674 
18677  bool Pop();
18678 
18685  bool Pop(Style::Type & out_type, SegmentKey & out_segment_source, UTF8 & out_style_name, ConditionalExpression & out_conditional);
18686 
18690  void Flush(SegmentKey const & in_style_source);
18691 
18698  void Flush(SegmentKey const & in_style_source, ConditionalExpression const & in_conditional);
18699 
18703  void Flush(char const * in_style_name);
18704 
18711  void Flush(char const * in_style_name, ConditionalExpression const & in_conditional);
18712 
18713 
18716  StyleKey SetNamed(char const * in_style_name);
18717 
18721  StyleKey SetNamed(char const * in_style_name, ConditionalExpression const & in_conditional);
18722 
18723 
18726  StyleKey SetSegment(SegmentKey const & in_style_source);
18727 
18731  StyleKey SetSegment(SegmentKey const & in_style_source, ConditionalExpression const & in_conditional);
18732 
18733 
18739  void Set(StyleTypeArray const & in_types, SegmentKeyArray const & in_segment_sources, UTF8Array const & in_style_names, ConditionalExpressionArray const & in_conditions);
18740 
18745  void Set(StyleTypeArray const & in_types, SegmentKeyArray const & in_segment_sources, UTF8Array const & in_style_names);
18746 
18753  void Set(size_t in_count, Style::Type const in_types[], SegmentKey const in_segment_sources[], UTF8 const in_style_names[], ConditionalExpression const in_conditions[]);
18754 
18755 
18756 
18758  void UnsetTop();
18759 
18761  void UnsetAllSegment();
18762 
18764  void UnsetAllNamed();
18765 
18767  void UnsetEverything();
18768 
18769 
18776  bool ShowTop(Style::Type & out_type, SegmentKey & out_segment_source, UTF8 & out_style_name, ConditionalExpression & out_conditional) const;
18777 
18781  bool ShowTop(StyleKey & out_style) const;
18782 
18789  bool Show(StyleTypeArray & out_types, SegmentKeyArray & out_segment_sources, UTF8Array & out_style_names, ConditionalExpressionArray & out_conditions) const;
18790 
18794  bool Show(StyleKeyArray & out_styles) const;
18795 
18800  bool ShowAllSegment(SegmentKeyArray & out_segments, HPS::ConditionalExpressionArray & out_conditions) const;
18801 
18805  bool ShowAllSegment(StyleKeyArray & out_styles) const;
18806 
18811  bool ShowAllNamed(UTF8Array & out_names, HPS::ConditionalExpressionArray & out_conditions) const;
18812 
18816  bool ShowAllNamed(StyleKeyArray & out_styles) const;
18817 
18818 private:
18819  StyleControl();
18820 };
18821 
18822 
18825 class HPS_API ConditionControl : public Control
18826 {
18827 public:
18829  explicit ConditionControl(SegmentKey & in_seg);
18830 
18832  ConditionControl(ConditionControl const & in_that);
18833 
18837  ConditionControl(ConditionControl && in_that);
18838 
18842  ConditionControl & operator=(ConditionControl && in_that);
18843 
18845  ~ConditionControl();
18846 
18847  virtual HPS::Type Type() const { return ObjectType(); }
18848 
18849  static const HPS::Type staticType = HPS::Type::ConditionControl;
18850  HPS::Type ObjectType() const { return staticType; };
18851 
18855  ConditionControl & operator=(ConditionControl const & in_that);
18856 
18859  size_t GetCount() const;
18860 
18864  ConditionControl & AddCondition(char const * in_condition);
18865 
18866 
18870  ConditionControl & SetCondition(char const * in_condition);
18871 
18875  ConditionControl & SetConditions(UTF8Array const & in_conditions);
18876 
18881  ConditionControl & SetConditions(size_t in_count, UTF8 const in_conditions []);
18882 
18883 
18887  ConditionControl & UnsetCondition(char const * in_condition);
18888 
18891  ConditionControl & UnsetEverything();
18892 
18893 
18897  bool ShowCondition(char const * in_condition) const;
18898 
18902  bool ShowConditions(UTF8Array & out_conditions) const;
18903 
18904 private:
18906  ConditionControl();
18907 };
18908 
18909 
18912 class HPS_API MaterialKit : public Kit
18913 {
18914 public:
18915 
18917  MaterialKit();
18918 
18921  MaterialKit(MaterialKit const & in_kit);
18922 
18926  MaterialKit(MaterialKit && in_that);
18927 
18931  MaterialKit & operator=(MaterialKit && in_that);
18932 
18934  ~MaterialKit();
18935 
18936  static const HPS::Type staticType = HPS::Type::MaterialKit;
18937  HPS::Type ObjectType() const {return staticType;};
18938 
18941  void Set(MaterialKit const & in_kit);
18942 
18945  void Show(MaterialKit & out_kit) const;
18946 
18950  MaterialKit & operator=(MaterialKit const & in_kit);
18951 
18954  bool Empty() const;
18955 
18959  bool Equals(MaterialKit const & in_kit) const;
18960 
18964  bool operator==(MaterialKit const & in_kit) const;
18965 
18969  bool operator!=(MaterialKit const & in_kit) const;
18970 
18971 
18972  //Set
18973 
18977  MaterialKit & SetDiffuse(RGBColor const & in_color);
18978 
18982  MaterialKit & SetDiffuse(RGBAColor const & in_color);
18983 
18987  MaterialKit & SetDiffuseColor(RGBColor const & in_color);
18988 
18992  MaterialKit & SetDiffuseColor(RGBAColor const & in_color);
18993 
18998  MaterialKit & SetDiffuseAlpha(float in_alpha);
18999 
19006  MaterialKit & SetDiffuseTexture(char const * in_texture_name, size_t in_layer=0);
19007 
19015  MaterialKit & SetDiffuseTexture(char const * in_texture_name, RGBAColor const & in_modulating_color, size_t in_layer=0);
19016 
19021  MaterialKit & SetDiffuseTexture(UTF8Array const & in_texture_names);
19022 
19028  MaterialKit & SetDiffuseTexture(size_t in_count, UTF8 const in_texture_names []);
19029 
19036  MaterialKit & SetDiffuseTexture(UTF8Array const & in_texture_names, RGBAColorArray const & in_modulating_colors);
19037 
19045  MaterialKit & SetDiffuseTexture(size_t in_count, UTF8 const in_texture_names [], RGBAColor const in_modulating_colors []);
19046 
19047 
19051  MaterialKit & SetShader(char const * in_shader_name);
19052 
19053 
19054 
19058  MaterialKit & SetSpecular(RGBAColor const & in_rgba_color);
19059 
19063  MaterialKit & SetSpecular(char const * in_texture_name);
19064 
19069  MaterialKit & SetSpecular(char const * in_texture_name, RGBAColor const & in_modulating_color);
19070 
19071 
19072 
19076  MaterialKit & SetMirror(RGBAColor const & in_rgba_color);
19077 
19081  MaterialKit & SetMirror(char const * in_texture_name);
19082 
19087  MaterialKit & SetMirror(char const * in_texture_name, RGBAColor const & in_modulating_color);
19088 
19089 
19090 
19094  MaterialKit & SetTransmission(char const * in_texture_name);
19095 
19100  MaterialKit & SetTransmission(char const * in_texture_name, RGBAColor const & in_modulating_color);
19101 
19102 
19103 
19107  MaterialKit & SetEmission(RGBAColor const & in_rgba_color);
19108 
19112  MaterialKit & SetEmission(char const * in_texture_name);
19113 
19118  MaterialKit & SetEmission(char const * in_texture_name, RGBAColor const & in_modulating_color);
19119 
19120 
19121 
19125  MaterialKit & SetEnvironmentTexture(char const * in_texture_name);
19126 
19131  MaterialKit & SetEnvironmentTexture(char const * in_texture_name, RGBAColor const & in_modulating_color);
19132 
19136  MaterialKit & SetEnvironmentCubeMap(char const * in_cubemap_name);
19137 
19142  MaterialKit & SetEnvironmentCubeMap(char const * in_cubemap_name, RGBAColor const & in_modulating_color);
19143 
19146  MaterialKit & SetEnvironmentTexture();
19147 
19148 
19152  MaterialKit & SetBump(char const * in_texture_name);
19153 
19154 
19155 
19162  MaterialKit & SetGloss(float in_gloss);
19163 
19166  MaterialKit & UnsetDiffuseColorRGB();
19167 
19170  MaterialKit & UnsetDiffuseColor();
19171 
19174  MaterialKit & UnsetDiffuseAlpha();
19175 
19178  MaterialKit & UnsetDiffuseTexture();
19179 
19183  MaterialKit & UnsetDiffuseTexture(size_t in_layer);
19184 
19187  MaterialKit & UnsetShader();
19188 
19191  MaterialKit & UnsetSpecular();
19192 
19195  MaterialKit & UnsetMirror();
19196 
19199  MaterialKit & UnsetTransmission();
19200 
19203  MaterialKit & UnsetEmission();
19204 
19207  MaterialKit & UnsetEnvironment();
19208 
19211  MaterialKit & UnsetBump();
19212 
19215  MaterialKit & UnsetGloss();
19216 
19219  MaterialKit & UnsetEverything();
19220 
19221 
19224  bool ShowDiffuse() const;
19225 
19229  bool ShowDiffuseColor(RGBColor & out_rgb_color) const;
19230 
19234  bool ShowDiffuseColor(RGBAColor & out_rgba_color) const;
19235 
19239  bool ShowDiffuseAlpha(float & out_alpha) const;
19240 
19247  bool ShowDiffuseTexture(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
19248 
19256  bool ShowDiffuseTexture(size_t in_layer, Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
19257 
19264  bool ShowDiffuseTexture(MaterialTypeArray & out_types, RGBAColorArray & out_colors, UTF8Array & out_texture_names) const;
19265 
19269  bool ShowShader(UTF8 & out_shader_name) const;
19270 
19279  bool ShowSpecular(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
19280 
19289  bool ShowMirror(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
19290 
19291 
19292 
19301  bool ShowTransmission(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
19302 
19303 
19312  bool ShowEmission(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
19313 
19314 
19323  bool ShowEnvironment(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
19324 
19325 
19329  bool ShowBump(UTF8 & out_texture_name) const;
19330 
19335  bool ShowGloss(float & out_gloss) const;
19336 };
19337 
19338 
19340 class HPS_API NURBSSurfaceAttributeKit : public Kit
19341 {
19342 public:
19343 
19346 
19350 
19355 
19359  NURBSSurfaceAttributeKit & operator=(NURBSSurfaceAttributeKit && in_that);
19360 
19362  virtual ~NURBSSurfaceAttributeKit();
19363 
19364  static const HPS::Type staticType = HPS::Type::NURBSSurfaceAttributeKit;
19365  HPS::Type ObjectType() const {return staticType;};
19366 
19370  static NURBSSurfaceAttributeKit GetDefault();
19371 
19374  void Set(NURBSSurfaceAttributeKit const & in_kit);
19375 
19378  void Show(NURBSSurfaceAttributeKit & out_kit) const;
19379 
19383  NURBSSurfaceAttributeKit & operator=(NURBSSurfaceAttributeKit const & in_kit);
19384 
19387  bool Empty() const;
19388 
19392  bool Equals(NURBSSurfaceAttributeKit const & in_kit) const;
19393 
19397  bool operator==(NURBSSurfaceAttributeKit const & in_kit) const;
19398 
19402  bool operator!=(NURBSSurfaceAttributeKit const & in_kit) const;
19403 
19404 
19408  NURBSSurfaceAttributeKit & SetBudget(size_t in_budget);
19409 
19414  NURBSSurfaceAttributeKit & SetMaximumDeviation(float in_deviation);
19415 
19419  NURBSSurfaceAttributeKit & SetMaximumAngle(float in_degrees);
19420 
19424  NURBSSurfaceAttributeKit & SetMaximumWidth(float in_width);
19425 
19429  NURBSSurfaceAttributeKit & SetTrimBudget(size_t in_budget);
19430 
19435  NURBSSurfaceAttributeKit & SetMaximumTrimDeviation(float in_deviation);
19436 
19437 
19440  NURBSSurfaceAttributeKit & UnsetBudget();
19441 
19444  NURBSSurfaceAttributeKit & UnsetMaximumDeviation();
19445 
19448  NURBSSurfaceAttributeKit & UnsetMaximumAngle();
19449 
19452  NURBSSurfaceAttributeKit & UnsetMaximumWidth();
19453 
19456  NURBSSurfaceAttributeKit & UnsetTrimBudget();
19457 
19460  NURBSSurfaceAttributeKit & UnsetMaximumTrimDeviation();
19461 
19464  NURBSSurfaceAttributeKit & UnsetEverything();
19465 
19469  bool ShowBudget(size_t & out_budget) const;
19470 
19474  bool ShowMaximumDeviation(float & out_deviation) const;
19475 
19479  bool ShowMaximumAngle(float & out_degrees) const;
19480 
19484  bool ShowMaximumWidth(float & out_width) const;
19485 
19489  bool ShowTrimBudget(size_t & out_budget) const;
19490 
19494  bool ShowMaximumTrimDeviation(float & out_deviation) const;
19495 };
19496 
19503 {
19504 public:
19505 
19507  explicit NURBSSurfaceAttributeControl(SegmentKey & in_seg);
19508 
19511 
19516 
19521 
19524 
19525  virtual HPS::Type Type() const { return ObjectType(); }
19526 
19527  static const HPS::Type staticType = HPS::Type::NURBSSurfaceAttributeControl;
19528  HPS::Type ObjectType() const {return staticType;};
19529 
19533  NURBSSurfaceAttributeControl & operator=(NURBSSurfaceAttributeControl const & in_that);
19534 
19538  NURBSSurfaceAttributeControl & SetBudget(size_t in_budget);
19539 
19544  NURBSSurfaceAttributeControl & SetMaximumDeviation(float in_deviation);
19545 
19549  NURBSSurfaceAttributeControl & SetMaximumAngle(float in_degrees);
19550 
19554  NURBSSurfaceAttributeControl & SetMaximumWidth(float in_width);
19555 
19559  NURBSSurfaceAttributeControl & SetTrimBudget(size_t in_budget);
19560 
19565  NURBSSurfaceAttributeControl & SetMaximumTrimDeviation(float in_deviation);
19566 
19567 
19571  NURBSSurfaceAttributeControl & UnsetBudget();
19572 
19576  NURBSSurfaceAttributeControl & UnsetMaximumDeviation();
19577 
19581  NURBSSurfaceAttributeControl & UnsetMaximumAngle();
19582 
19586  NURBSSurfaceAttributeControl & UnsetMaximumWidth();
19587 
19591  NURBSSurfaceAttributeControl & UnsetTrimBudget();
19592 
19596  NURBSSurfaceAttributeControl & UnsetMaximumTrimDeviation();
19597 
19601  NURBSSurfaceAttributeControl & UnsetEverything();
19602 
19603 
19607  bool ShowBudget(size_t & out_budget) const;
19608 
19612  bool ShowMaximumDeviation(float & out_deviation) const;
19613 
19617  bool ShowMaximumAngle(float & out_degrees) const;
19618 
19622  bool ShowMaximumWidth(float & out_width) const;
19623 
19627  bool ShowTrimBudget(size_t & out_budget) const;
19628 
19632  bool ShowMaximumTrimDeviation(float & out_deviation) const;
19633 
19634 private:
19637 };
19638 
19639 
19640 
19642 class HPS_API PerformanceKit : public Kit
19643 {
19644 public:
19645 
19647  PerformanceKit();
19648 
19651  PerformanceKit(PerformanceKit const & in_kit);
19652 
19656  PerformanceKit(PerformanceKit && in_that);
19657 
19661  PerformanceKit & operator=(PerformanceKit && in_that);
19662 
19664  virtual ~PerformanceKit();
19665 
19666  static const HPS::Type staticType = HPS::Type::PerformanceKit;
19667  HPS::Type ObjectType() const {return staticType;};
19668 
19672  static PerformanceKit GetDefault();
19673 
19676  void Set(PerformanceKit const & in_kit);
19677 
19680  void Show(PerformanceKit & out_kit) const;
19681 
19685  PerformanceKit & operator=(PerformanceKit const & in_kit);
19686 
19689  bool Empty() const;
19690 
19694  bool Equals(PerformanceKit const & in_kit) const;
19695 
19699  bool operator==(PerformanceKit const & in_kit) const;
19700 
19704  bool operator!=(PerformanceKit const & in_kit) const;
19705 
19706 
19711 
19716  PerformanceKit & SetStaticModel(Performance::StaticModel in_model_type);
19717 
19718 
19721  PerformanceKit & UnsetDisplayLists();
19722 
19725  PerformanceKit & UnsetStaticModel();
19726 
19729  PerformanceKit & UnsetEverything();
19730 
19734  bool ShowDisplayLists(Performance::DisplayLists & out_display_list) const;
19735 
19739  bool ShowStaticModel(Performance::StaticModel & out_model_type) const;
19740 };
19741 
19742 
19748 class HPS_API PerformanceControl : public Control
19749 {
19750 public:
19751 
19753  explicit PerformanceControl(SegmentKey & in_seg);
19754 
19756  PerformanceControl(PerformanceControl const & in_that);
19757 
19762 
19766  PerformanceControl & operator=(PerformanceControl && in_that);
19767 
19769  ~PerformanceControl();
19770 
19771  virtual HPS::Type Type() const { return ObjectType(); }
19772 
19773  static const HPS::Type staticType = HPS::Type::PerformanceControl;
19774  HPS::Type ObjectType() const {return staticType;};
19775 
19779  PerformanceControl & operator=(PerformanceControl const & in_that);
19780 
19785 
19790  PerformanceControl & SetStaticModel(Performance::StaticModel in_model_type);
19791 
19792 
19796  PerformanceControl & UnsetDisplayLists();
19797 
19801  PerformanceControl & UnsetStaticModel();
19802 
19806  PerformanceControl & UnsetEverything();
19807 
19808 
19812  bool ShowDisplayLists(Performance::DisplayLists & out_display_list) const;
19813 
19817  bool ShowStaticModel(Performance::StaticModel & out_model_type) const;
19818 
19819 private:
19822 };
19823 
19824 
19825 
19827 class HPS_API HiddenLineAttributeKit : public Kit
19828 {
19829 public:
19830 
19833 
19837 
19842 
19846  HiddenLineAttributeKit & operator=(HiddenLineAttributeKit && in_that);
19847 
19849  virtual ~HiddenLineAttributeKit();
19850 
19851  static const HPS::Type staticType = HPS::Type::HiddenLineAttributeKit;
19852  HPS::Type ObjectType() const {return staticType;};
19853 
19857  static HiddenLineAttributeKit GetDefault();
19858 
19861  void Set(HiddenLineAttributeKit const & in_kit);
19862 
19865  void Show(HiddenLineAttributeKit & out_kit) const;
19866 
19870  HiddenLineAttributeKit & operator=(HiddenLineAttributeKit const & in_kit);
19871 
19874  bool Empty() const;
19875 
19879  bool Equals(HiddenLineAttributeKit const & in_kit) const;
19880 
19884  bool operator==(HiddenLineAttributeKit const & in_kit) const;
19885 
19889  bool operator!=(HiddenLineAttributeKit const & in_kit) const;
19890 
19891 
19896  HiddenLineAttributeKit & SetAlgorithm(HiddenLine::Algorithm in_algorithm);
19897 
19901  HiddenLineAttributeKit & SetColor(RGBAColor const & in_color);
19902 
19908  HiddenLineAttributeKit & SetDimFactor(float in_zero_to_one);
19909 
19920  HiddenLineAttributeKit & SetFaceDisplacement(float in_buckets);
19921 
19925  HiddenLineAttributeKit & SetLinePattern(char const * in_pattern);
19926 
19940  HiddenLineAttributeKit & SetLineSorting(bool in_state, float in_threshold=2.0f, Line::SizeUnits in_units=HPS::Line::SizeUnits::Pixels);
19941 
19945  HiddenLineAttributeKit & SetRenderFaces(bool in_state);
19946 
19950  HiddenLineAttributeKit & SetRenderText(bool in_state);
19951 
19957  HiddenLineAttributeKit & SetSilhouetteCleanup(bool in_state);
19958 
19964  HiddenLineAttributeKit & SetTransparencyCutoff(float in_zero_to_one);
19965 
19969  HiddenLineAttributeKit & SetVisibility(bool in_state);
19970 
19975  HiddenLineAttributeKit & SetWeight(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
19976 
19979  HiddenLineAttributeKit & UnsetAlgorithm();
19980 
19983  HiddenLineAttributeKit & UnsetColor();
19984 
19987  HiddenLineAttributeKit & UnsetDimFactor();
19988 
19991  HiddenLineAttributeKit & UnsetFaceDisplacement();
19992 
19995  HiddenLineAttributeKit & UnsetLinePattern();
19996 
19999  HiddenLineAttributeKit & UnsetLineSorting();
20000 
20003  HiddenLineAttributeKit & UnsetRenderFaces();
20004 
20007  HiddenLineAttributeKit & UnsetRenderText();
20008 
20011  HiddenLineAttributeKit & UnsetSilhouetteCleanup();
20012 
20015  HiddenLineAttributeKit & UnsetTransparencyCutoff();
20016 
20019  HiddenLineAttributeKit & UnsetVisibility();
20020 
20023  HiddenLineAttributeKit & UnsetWeight();
20024 
20027  HiddenLineAttributeKit & UnsetEverything();
20028 
20029 
20033  bool ShowAlgorithm(HiddenLine::Algorithm & out_algorithm) const;
20034 
20038  bool ShowColor(RGBAColor & out_color) const;
20039 
20043  bool ShowDimFactor(float & out_zero_to_one) const;
20044 
20048  bool ShowFaceDisplacement(float & out_buckets) const;
20049 
20053  bool ShowLinePattern(UTF8 & out_pattern) const;
20054 
20060  bool ShowLineSorting(bool & out_state, float & out_threshold, Line::SizeUnits & out_units) const;
20061 
20065  bool ShowRenderFaces(bool & out_state) const;
20066 
20070  bool ShowRenderText(bool & out_state) const;
20071 
20075  bool ShowSilhouetteCleanup(bool & out_state) const;
20076 
20080  bool ShowTransparencyCutoff(float & out_zero_to_one) const;
20081 
20085  bool ShowVisibility(bool & out_state) const;
20086 
20091  bool ShowWeight(float & out_weight, Line::SizeUnits & out_units) const;
20092 };
20093 
20094 
20100 class HPS_API HiddenLineAttributeControl : public Control
20101 {
20102 public:
20103 
20105  explicit HiddenLineAttributeControl(SegmentKey & in_seg);
20106 
20109 
20114 
20119 
20122 
20123  virtual HPS::Type Type() const { return ObjectType(); }
20124 
20125  static const HPS::Type staticType = HPS::Type::HiddenLineAttributeControl;
20126  HPS::Type ObjectType() const {return staticType;};
20127 
20131  HiddenLineAttributeControl & operator=(HiddenLineAttributeControl const & in_that);
20132 
20137  HiddenLineAttributeControl & SetAlgorithm(HiddenLine::Algorithm in_algorithm);
20138 
20142  HiddenLineAttributeControl & SetColor(RGBAColor const & in_color);
20143 
20149  HiddenLineAttributeControl & SetDimFactor(float in_zero_to_one);
20150 
20161  HiddenLineAttributeControl & SetFaceDisplacement(float in_buckets);
20162 
20166  HiddenLineAttributeControl & SetLinePattern(char const * in_pattern);
20167 
20180  HiddenLineAttributeControl & SetLineSorting(bool in_on, float in_activation_weight = 2, Line::SizeUnits in_units = Line::SizeUnits::Pixels);
20181 
20185  HiddenLineAttributeControl & SetRenderFaces(bool in_state);
20186 
20190  HiddenLineAttributeControl & SetRenderText(bool in_state);
20191 
20197  HiddenLineAttributeControl & SetSilhouetteCleanup(bool in_state);
20198 
20204  HiddenLineAttributeControl & SetTransparencyCutoff(float in_zero_to_one);
20205 
20209  HiddenLineAttributeControl & SetVisibility(bool in_state);
20210 
20215  HiddenLineAttributeControl & SetWeight(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
20216 
20220  HiddenLineAttributeControl & UnsetAlgorithm();
20221 
20225  HiddenLineAttributeControl & UnsetColor();
20226 
20230  HiddenLineAttributeControl & UnsetDimFactor();
20231 
20235  HiddenLineAttributeControl & UnsetFaceDisplacement();
20236 
20240  HiddenLineAttributeControl & UnsetLinePattern();
20241 
20245  HiddenLineAttributeControl & UnsetLineSorting();
20246 
20250  HiddenLineAttributeControl & UnsetRenderFaces();
20251 
20255  HiddenLineAttributeControl & UnsetRenderText();
20256 
20260  HiddenLineAttributeControl & UnsetSilhouetteCleanup();
20261 
20265  HiddenLineAttributeControl & UnsetTransparencyCutoff();
20266 
20270  HiddenLineAttributeControl & UnsetVisibility();
20271 
20275  HiddenLineAttributeControl & UnsetWeight();
20276 
20280  HiddenLineAttributeControl & UnsetEverything();
20281 
20282 
20286  bool ShowAlgorithm(HiddenLine::Algorithm & out_algorithm) const;
20287 
20291  bool ShowColor(RGBAColor & out_color) const;
20292 
20296  bool ShowDimFactor(float & out_zero_to_one) const;
20297 
20301  bool ShowFaceDisplacement(float & out_buckets) const;
20302 
20306  bool ShowLinePattern(UTF8 & out_pattern) const;
20307 
20313  bool ShowLineSorting(bool & out_state, float & out_threshold, Line::SizeUnits & out_units) const;
20314 
20318  bool ShowRenderFaces(bool & out_state) const;
20319 
20323  bool ShowRenderText(bool & out_state) const;
20324 
20328  bool ShowSilhouetteCleanup(bool & out_state) const;
20329 
20333  bool ShowTransparencyCutoff(float & out_zero_to_one) const;
20334 
20338  bool ShowVisibility(bool & out_state) const;
20339 
20344  bool ShowWeight(float & out_weight, Line::SizeUnits & out_units) const;
20345 
20346 private:
20349 };
20350 
20351 
20352 
20354 class HPS_API DrawingAttributeKit : public Kit
20355 {
20356 public:
20357 
20360 
20363  DrawingAttributeKit(DrawingAttributeKit const & in_kit);
20364 
20369 
20373  DrawingAttributeKit & operator=(DrawingAttributeKit && in_that);
20374 
20376  virtual ~DrawingAttributeKit();
20377 
20378  static const HPS::Type staticType = HPS::Type::DrawingAttributeKit;
20379  HPS::Type ObjectType() const {return staticType;};
20380 
20384  static DrawingAttributeKit GetDefault();
20385 
20388  void Set(DrawingAttributeKit const & in_kit);
20389 
20392  void Show(DrawingAttributeKit & out_kit) const;
20393 
20397  DrawingAttributeKit & operator=(DrawingAttributeKit const & in_kit);
20398 
20401  bool Empty() const;
20402 
20406  bool Equals(DrawingAttributeKit const & in_kit) const;
20407 
20411  bool operator==(DrawingAttributeKit const & in_kit) const;
20412 
20416  bool operator!=(DrawingAttributeKit const & in_kit) const;
20417 
20433  DrawingAttributeKit & SetPolygonHandedness(Drawing::Handedness in_handedness);
20434 
20440  DrawingAttributeKit & SetWorldHandedness(Drawing::Handedness in_handedness);
20441 
20454  DrawingAttributeKit & SetDepthRange(float in_near, float in_far);
20455 
20464  DrawingAttributeKit & SetFaceDisplacement(bool in_state, int in_buckets=0);
20465 
20472  DrawingAttributeKit & SetFaceDisplacement(int in_buckets);
20473 
20482  DrawingAttributeKit & SetGeneralDisplacement(bool in_state, int in_buckets=0);
20483 
20490  DrawingAttributeKit & SetGeneralDisplacement(int in_buckets);
20491 
20500  DrawingAttributeKit & SetVertexDisplacement(bool in_state, int in_buckets=0);
20501 
20507  DrawingAttributeKit & SetVertexDisplacement(int in_buckets);
20508 
20512  DrawingAttributeKit & SetVertexDecimation(float in_zero_to_one);
20513 
20517  DrawingAttributeKit & SetVertexRandomization(bool in_state);
20518 
20522  DrawingAttributeKit & SetOverrideInternalColor(VisibilityKit const & in_kit);
20523 
20527  DrawingAttributeKit & SetOverlay(Drawing::Overlay in_overlay);
20528 
20533  DrawingAttributeKit & SetDeferral(int in_deferral);
20534 
20541 
20548  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);
20549 
20556 
20559  DrawingAttributeKit & UnsetPolygonHandedness();
20560 
20563  DrawingAttributeKit & UnsetWorldHandedness();
20564 
20567  DrawingAttributeKit & UnsetDepthRange();
20568 
20571  DrawingAttributeKit & UnsetFaceDisplacement();
20572 
20575  DrawingAttributeKit & UnsetGeneralDisplacement();
20576 
20579  DrawingAttributeKit & UnsetVertexDisplacement();
20580 
20583  DrawingAttributeKit & UnsetVertexDecimation();
20584 
20587  DrawingAttributeKit & UnsetVertexRandomization();
20588 
20591  DrawingAttributeKit & UnsetOverrideInternalColor();
20592 
20595  DrawingAttributeKit & UnsetOverlay();
20596 
20599  DrawingAttributeKit & UnsetDeferral();
20600 
20603  DrawingAttributeKit & UnsetClipRegion();
20604 
20607  DrawingAttributeKit & UnsetEverything();
20608 
20612  bool ShowPolygonHandedness(Drawing::Handedness & out_handedness) const;
20613 
20617  bool ShowWorldHandedness(Drawing::Handedness & out_handedness) const;
20618 
20623  bool ShowDepthRange(float & out_near, float & out_far) const;
20624 
20629  bool ShowFaceDisplacement(bool & out_state, int & out_buckets) const;
20630 
20635  bool ShowGeneralDisplacement(bool & out_state, int & out_buckets) const;
20636 
20641  bool ShowVertexDisplacement(bool & out_state, int & out_buckets) const;
20642 
20646  bool ShowVertexDecimation(float & out_zero_to_one) const;
20647 
20651  bool ShowVertexRandomization(bool & out_state) const;
20652 
20656  bool ShowOverrideInternalColor(VisibilityKit & out_kit) const;
20657 
20661  bool ShowOverlay(Drawing::Overlay & out_overlay) const;
20662 
20666  bool ShowDeferral(int & out_defer_batch) const;
20667 
20673  bool ShowClipRegion(PointArrayArray & out_loops, Drawing::ClipSpace & out_space, Drawing::ClipOperation & out_operation) const;
20674 
20675 };
20676 
20677 
20694 class HPS_API DrawingAttributeControl : public Control
20695 {
20696 public:
20697 
20699  explicit DrawingAttributeControl(SegmentKey & in_seg);
20700 
20703 
20708 
20712  DrawingAttributeControl & operator=(DrawingAttributeControl && in_that);
20713 
20716 
20717  virtual HPS::Type Type() const { return ObjectType(); }
20718 
20719  static const HPS::Type staticType = HPS::Type::DrawingAttributeControl;
20720  HPS::Type ObjectType() const {return staticType;};
20721 
20725  DrawingAttributeControl & operator=(DrawingAttributeControl const & in_that);
20726 
20736  DrawingAttributeControl & SetPolygonHandedness(Drawing::Handedness in_handedness);
20737 
20743  DrawingAttributeControl & SetWorldHandedness(Drawing::Handedness in_handedness);
20744 
20757  DrawingAttributeControl & SetDepthRange(float in_near, float in_far);
20758 
20767  DrawingAttributeControl & SetFaceDisplacement(bool in_state, int in_buckets=0);
20768 
20775  DrawingAttributeControl & SetFaceDisplacement(int in_buckets);
20776 
20785  DrawingAttributeControl & SetGeneralDisplacement(bool in_state, int in_buckets=0);
20786 
20793  DrawingAttributeControl & SetGeneralDisplacement(int in_buckets);
20794 
20803  DrawingAttributeControl & SetVertexDisplacement(bool in_state, int in_buckets=0);
20804 
20810  DrawingAttributeControl & SetVertexDisplacement(int in_buckets);
20811 
20815  DrawingAttributeControl & SetVertexDecimation(float in_zero_to_one);
20816 
20820  DrawingAttributeControl & SetVertexRandomization(bool in_state);
20821 
20825  DrawingAttributeControl & SetOverrideInternalColor(VisibilityKit const & in_kit);
20826 
20830  DrawingAttributeControl & SetOverlay(Drawing::Overlay in_overlay);
20831 
20838 
20845  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);
20846 
20853 
20858  DrawingAttributeControl & SetDeferral(int in_deferral);
20859 
20863  DrawingAttributeControl & UnsetPolygonHandedness();
20864 
20868  DrawingAttributeControl & UnsetWorldHandedness();
20869 
20873  DrawingAttributeControl & UnsetDepthRange();
20874 
20878  DrawingAttributeControl & UnsetFaceDisplacement();
20879 
20883  DrawingAttributeControl & UnsetGeneralDisplacement();
20884 
20888  DrawingAttributeControl & UnsetVertexDisplacement();
20889 
20893  DrawingAttributeControl & UnsetVertexDecimation();
20894 
20898  DrawingAttributeControl & UnsetVertexRandomization();
20899 
20903  DrawingAttributeControl & UnsetOverrideInternalColor();
20904 
20908  DrawingAttributeControl & UnsetOverlay();
20909 
20913  DrawingAttributeControl & UnsetDeferral();
20914 
20918  DrawingAttributeControl & UnsetClipRegion();
20919 
20923  DrawingAttributeControl & UnsetEverything();
20924 
20925 
20929  bool ShowPolygonHandedness(Drawing::Handedness & out_handedness) const;
20930 
20934  bool ShowWorldHandedness(Drawing::Handedness & out_handedness) const;
20935 
20940  bool ShowDepthRange(float & out_x, float & out_y) const;
20941 
20946  bool ShowFaceDisplacement(bool & out_state, int & out_buckets) const;
20947 
20952  bool ShowGeneralDisplacement(bool & out_state, int & out_buckets) const;
20953 
20958  bool ShowVertexDisplacement(bool & out_state, int & out_buckets) const;
20959 
20963  bool ShowVertexDecimation(float & out_zero_to_one) const;
20964 
20968  bool ShowVertexRandomization(bool & out_state) const;
20969 
20973  bool ShowOverrideInternalColor(VisibilityKit & out_kit) const;
20974 
20978  bool ShowOverlay(Drawing::Overlay & out_overlay) const;
20979 
20983  bool ShowDeferral(int & out_defer_batch) const;
20984 
20990  bool ShowClipRegion(PointArrayArray & out_loops, Drawing::ClipSpace & out_space, Drawing::ClipOperation & out_operation) const;
20991 
20992 private:
20995 };
20996 
20997 
20999 class HPS_API PostProcessEffectsKit : public Kit
21000 {
21001 public:
21002 
21005 
21009 
21014 
21018  PostProcessEffectsKit & operator=(PostProcessEffectsKit && in_that);
21019 
21021  virtual ~PostProcessEffectsKit();
21022 
21023  static const HPS::Type staticType = HPS::Type::PostProcessEffectsKit;
21024  HPS::Type ObjectType() const {return staticType;};
21025 
21029  static PostProcessEffectsKit GetDefault();
21030 
21033  void Set(PostProcessEffectsKit const & in_kit);
21034 
21037  void Show(PostProcessEffectsKit & out_kit) const;
21038 
21042  PostProcessEffectsKit & operator=(PostProcessEffectsKit const & in_kit);
21043 
21046  bool Empty() const;
21047 
21051  bool Equals(PostProcessEffectsKit const & in_kit) const;
21052 
21056  bool operator==(PostProcessEffectsKit const & in_kit) const;
21057 
21061  bool operator!=(PostProcessEffectsKit const & in_kit) const;
21062 
21063 
21075  PostProcessEffectsKit & SetAmbientOcclusion(bool in_state, float in_strength = 1.0f, PostProcessEffects::AmbientOcclusion::Quality in_quality = PostProcessEffects::AmbientOcclusion::Quality::Fastest, float in_radius = 1.0f, float in_sharpness = 32.0f);
21076 
21087  PostProcessEffectsKit & SetAmbientOcclusion(float in_strength, PostProcessEffects::AmbientOcclusion::Quality in_quality = PostProcessEffects::AmbientOcclusion::Quality::Fastest, float in_radius = 1.0f, float in_sharpness = 32.0f);
21088 
21095  PostProcessEffectsKit & SetBloom(bool in_state, float in_strength = 1.0f, unsigned int in_blur = 5, PostProcessEffects::Bloom::Shape in_shape = PostProcessEffects::Bloom::Shape::Radial);
21096 
21102  PostProcessEffectsKit & SetBloom(float in_strength, unsigned int in_blur, PostProcessEffects::Bloom::Shape in_shape);
21103 
21110  PostProcessEffectsKit & SetDepthOfField(bool in_state, float in_strength = 1.0f, float in_near_distance = Float::NegativeInfinity, float in_far_distance = Float::Infinity);
21111 
21117  PostProcessEffectsKit & SetDepthOfField(float in_strength, float in_near_distance, float in_far_distance);
21118 
21126  PostProcessEffectsKit & SetSilhouetteEdges(bool in_state, float in_tolerance = 1.0f, bool in_heavy_exterior = false);
21127 
21134  PostProcessEffectsKit & SetSilhouetteEdges(float in_tolerance, bool in_heavy_exterior);
21135 
21143  PostProcessEffectsKit & SetEyeDomeLighting(bool in_state, float in_exponent = 50.0f, float in_tolerance = 1.0f, float in_strength = 1.0f);
21144 
21151  PostProcessEffectsKit & SetEyeDomeLighting(float in_exponent, bool in_tolerance, float in_strength);
21152 
21156  PostProcessEffectsKit & SetWorldScale(float in_scale);
21157 
21160  PostProcessEffectsKit & UnsetAmbientOcclusion();
21161 
21164  PostProcessEffectsKit & UnsetBloom();
21165 
21168  PostProcessEffectsKit & UnsetDepthOfField();
21169 
21172  PostProcessEffectsKit & UnsetSilhouetteEdges();
21173 
21176  PostProcessEffectsKit & UnsetEyeDomeLighting();
21177 
21180  PostProcessEffectsKit & UnsetWorldScale();
21181 
21184  PostProcessEffectsKit & UnsetEverything();
21185 
21186 
21196  bool ShowAmbientOcclusion(bool & out_state, float & out_strength, PostProcessEffects::AmbientOcclusion::Quality & out_quality, float & out_radius, float & out_sharpness) const;
21197 
21204  bool ShowBloom(bool & out_state, float & out_strength, unsigned int & out_blur, PostProcessEffects::Bloom::Shape & out_shape) const;
21205 
21212  bool ShowDepthOfField(bool & out_state, float & out_strength, float & out_near_distance, float & out_far_distance) const;
21213 
21221  bool ShowSilhouetteEdges(bool & out_state, float & out_tolerance, bool & out_heavy_exterior) const;
21222 
21230  bool ShowEyeDomeLighting(bool & out_state, float & out_exponent, float & out_tolerance, float & out_strength) const;
21231 
21235  bool ShowWorldScale(float & out_scale) const;
21236 
21237 };
21238 
21239 
21243 class HPS_API PostProcessEffectsControl : public Control
21244 {
21245 public:
21246 
21248  explicit PostProcessEffectsControl(WindowKey & in_seg);
21249 
21252 
21257 
21261  PostProcessEffectsControl & operator=(PostProcessEffectsControl && in_that);
21262 
21265 
21266  virtual HPS::Type Type() const { return ObjectType(); }
21267 
21268  static const HPS::Type staticType = HPS::Type::PostProcessEffectsControl;
21269  HPS::Type ObjectType() const {return staticType;};
21270 
21274  PostProcessEffectsControl & operator=(PostProcessEffectsControl const & in_that);
21275 
21287  PostProcessEffectsControl & SetAmbientOcclusion(bool in_state, float in_strength = 1.0f, PostProcessEffects::AmbientOcclusion::Quality in_quality = PostProcessEffects::AmbientOcclusion::Quality::Fastest, float in_radius = 1.0f, float in_sharpness = 32.0f);
21288 
21299  PostProcessEffectsControl & SetAmbientOcclusion(float in_strength, PostProcessEffects::AmbientOcclusion::Quality in_quality = PostProcessEffects::AmbientOcclusion::Quality::Fastest, float in_radius = 1.0f, float in_sharpness = 32.0f);
21300 
21307  PostProcessEffectsControl & SetBloom(bool in_state, float in_strength = 1.0f, unsigned int in_blur = 5, PostProcessEffects::Bloom::Shape in_shape = PostProcessEffects::Bloom::Shape::Radial);
21308 
21314  PostProcessEffectsControl & SetBloom(float in_strength, unsigned int in_blur, PostProcessEffects::Bloom::Shape in_shape);
21315 
21322  PostProcessEffectsControl & SetDepthOfField(bool in_state, float in_strength = 1.0f, float in_near_distance = Float::NegativeInfinity, float in_far_distance = Float::Infinity);
21323 
21329  PostProcessEffectsControl & SetDepthOfField(float in_strength, float in_near_distance, float in_far_distance);
21330 
21338  PostProcessEffectsControl & SetSilhouetteEdges(bool in_state, float in_tolerance = 1.0f, bool in_heavy_exterior = false);
21339 
21346  PostProcessEffectsControl & SetSilhouetteEdges(float in_tolerance, bool in_heavy_exterior);
21347 
21355  PostProcessEffectsControl & SetEyeDomeLighting(bool in_state, float in_exponent = 50.0f, float in_tolerance = 1.0f, float in_strength = 1.0f);
21356 
21363  PostProcessEffectsControl & SetEyeDomeLighting(float in_exponent, float in_tolerance, float in_strength);
21364 
21368  PostProcessEffectsControl & SetWorldScale(float in_scale);
21369 
21373  PostProcessEffectsControl & UnsetAmbientOcclusion();
21374 
21378  PostProcessEffectsControl & UnsetBloom();
21379 
21383  PostProcessEffectsControl & UnsetDepthOfField();
21384 
21388  PostProcessEffectsControl & UnsetSilhouetteEdges();
21389 
21393  PostProcessEffectsControl & UnsetEyeDomeLighting();
21394 
21398  PostProcessEffectsControl & UnsetWorldScale();
21399 
21403  PostProcessEffectsControl & UnsetEverything();
21404 
21405 
21415  bool ShowAmbientOcclusion(bool & out_state, float & out_strength, PostProcessEffects::AmbientOcclusion::Quality & out_quality, float & out_radius, float & out_sharpness) const;
21416 
21423  bool ShowBloom(bool & out_state, float & out_strength, unsigned int & out_blur, PostProcessEffects::Bloom::Shape & out_shape) const;
21424 
21431  bool ShowDepthOfField(bool & out_state, float & out_strength, float & out_near_distance, float & out_far_distance) const;
21432 
21440  bool ShowSilhouetteEdges(bool & out_state, float & out_tolerance, bool & out_heavy_exterior) const;
21441 
21449  bool ShowEyeDomeLighting(bool & out_state, float & out_exponent, float & out_tolerance, float & out_strength) const;
21450 
21454  bool ShowWorldScale(float & out_scale) const;
21455 
21456 private:
21459 };
21460 
21462 class HPS_API TransformMaskKit : public Kit
21463 {
21464 public:
21465 
21467  TransformMaskKit();
21468 
21470  TransformMaskKit(TransformMaskKit const & in_kit);
21471 
21475  TransformMaskKit(TransformMaskKit && in_that);
21476 
21480  TransformMaskKit & operator=(TransformMaskKit && in_that);
21481 
21483  virtual ~TransformMaskKit();
21484 
21485  static const HPS::Type staticType = HPS::Type::TransformMaskKit;
21486  HPS::Type ObjectType() const {return staticType;};
21487 
21488  static TransformMaskKit GetDefault();
21489 
21491  void Set(TransformMaskKit const & in_kit);
21492 
21494  void Show(TransformMaskKit & out_kit) const;
21495 
21497  TransformMaskKit & operator=(TransformMaskKit const & in_kit);
21498 
21500  bool Empty() const;
21501 
21503  bool Equals(TransformMaskKit const & in_kit) const;
21504 
21506  bool operator==(TransformMaskKit const & in_kit) const;
21507 
21509  bool operator!=(TransformMaskKit const & in_kit) const;
21510 
21511 
21515  TransformMaskKit & SetCameraRotation(bool in_state);
21516 
21520  TransformMaskKit & SetCameraScale(bool in_state);
21521 
21525  TransformMaskKit & SetCameraTranslation(bool in_state);
21526 
21530  TransformMaskKit & SetCameraPerspectiveScale(bool in_state);
21531 
21535  TransformMaskKit & SetCameraProjection(bool in_state);
21536 
21540  TransformMaskKit & SetCameraOffset(bool in_state);
21541 
21545  TransformMaskKit & SetCameraNearLimit(bool in_state);
21546 
21550  TransformMaskKit & SetModellingMatrixRotation(bool in_state);
21551 
21555  TransformMaskKit & SetModellingMatrixScale(bool in_state);
21556 
21560  TransformMaskKit & SetModellingMatrixTranslation(bool in_state);
21561 
21565  TransformMaskKit & SetModellingMatrixOffset(bool in_state);
21566 
21567 
21571  TransformMaskKit & SetCameraEverything(bool in_state);
21572 
21576  TransformMaskKit & SetModellingMatrixEverything(bool in_state);
21577 
21581  TransformMaskKit & SetEverything(bool in_state);
21582 
21583 
21586  TransformMaskKit & UnsetCameraRotation();
21587 
21590  TransformMaskKit & UnsetCameraScale();
21591 
21594  TransformMaskKit & UnsetCameraTranslation();
21595 
21598  TransformMaskKit & UnsetCameraPerspectiveScale();
21599 
21602  TransformMaskKit & UnsetCameraProjection();
21603 
21606  TransformMaskKit & UnsetCameraOffset();
21607 
21610  TransformMaskKit & UnsetCameraNearLimit();
21611 
21614  TransformMaskKit & UnsetCameraEverything();
21615 
21618  TransformMaskKit & UnsetModellingMatrixRotation();
21619 
21622  TransformMaskKit & UnsetModellingMatrixScale();
21623 
21626  TransformMaskKit & UnsetModellingMatrixTranslation();
21627 
21630  TransformMaskKit & UnsetModellingMatrixOffset();
21631 
21634  TransformMaskKit & UnsetModellingMatrixEverything();
21635 
21638  TransformMaskKit & UnsetEverything();
21639 
21640 
21644  bool ShowCameraRotation(bool & out_state) const;
21645 
21649  bool ShowCameraScale(bool & out_state) const;
21650 
21654  bool ShowCameraTranslation(bool & out_state) const;
21655 
21659  bool ShowCameraPerspectiveScale(bool & out_state) const;
21660 
21664  bool ShowCameraProjection(bool & out_state) const;
21665 
21669  bool ShowCameraOffset(bool & out_state) const;
21670 
21674  bool ShowCameraNearLimit(bool & out_state) const;
21675 
21679  bool ShowModellingMatrixRotation(bool & out_state) const;
21680 
21684  bool ShowModellingMatrixScale(bool & out_state) const;
21685 
21689  bool ShowModellingMatrixTranslation(bool & out_state) const;
21690 
21694  bool ShowModellingMatrixOffset(bool & out_state) const;
21695 };
21696 
21697 
21702 class HPS_API TransformMaskControl : public Control
21703 {
21704 public:
21705 
21707  explicit TransformMaskControl(SegmentKey & in_seg);
21708 
21710  TransformMaskControl(TransformMaskControl const & in_that);
21711 
21716 
21720  TransformMaskControl & operator=(TransformMaskControl && in_that);
21721 
21724 
21725  virtual HPS::Type Type() const { return ObjectType(); }
21726 
21727  static const HPS::Type staticType = HPS::Type::TransformMaskControl;
21728  HPS::Type ObjectType() const {return staticType;};
21729 
21733  TransformMaskControl & operator=(TransformMaskControl const & in_that);
21734 
21738  TransformMaskControl & SetCameraRotation(bool in_state);
21739 
21743  TransformMaskControl & SetCameraScale(bool in_state);
21744 
21748  TransformMaskControl & SetCameraTranslation(bool in_state);
21749 
21753  TransformMaskControl & SetCameraPerspectiveScale(bool in_state);
21754 
21758  TransformMaskControl & SetCameraProjection(bool in_state);
21759 
21763  TransformMaskControl & SetCameraOffset(bool in_state);
21764 
21768  TransformMaskControl & SetCameraNearLimit(bool in_state);
21769 
21773  TransformMaskControl & SetModellingMatrixRotation(bool in_state);
21774 
21778  TransformMaskControl & SetModellingMatrixScale(bool in_state);
21779 
21783  TransformMaskControl & SetModellingMatrixTranslation(bool in_state);
21784 
21788  TransformMaskControl & SetModellingMatrixOffset(bool in_state);
21789 
21790 
21794  TransformMaskControl & SetCameraEverything(bool in_state);
21795 
21799  TransformMaskControl & SetModellingMatrixEverything(bool in_state);
21800 
21804  TransformMaskControl & SetEverything(bool in_state);
21805 
21806 
21810  TransformMaskControl & UnsetCameraRotation();
21811 
21815  TransformMaskControl & UnsetCameraScale();
21816 
21820  TransformMaskControl & UnsetCameraTranslation();
21821 
21825  TransformMaskControl & UnsetCameraPerspectiveScale();
21826 
21830  TransformMaskControl & UnsetCameraProjection();
21831 
21835  TransformMaskControl & UnsetCameraOffset();
21836 
21840  TransformMaskControl & UnsetCameraNearLimit();
21841 
21845  TransformMaskControl & UnsetCameraEverything();
21846 
21850  TransformMaskControl & UnsetModellingMatrixRotation();
21851 
21855  TransformMaskControl & UnsetModellingMatrixScale();
21856 
21860  TransformMaskControl & UnsetModellingMatrixTranslation();
21861 
21865  TransformMaskControl & UnsetModellingMatrixOffset();
21866 
21870  TransformMaskControl & UnsetModellingMatrixEverything();
21871 
21875  TransformMaskControl & UnsetEverything();
21876 
21877 
21881  bool ShowCameraRotation(bool & out_state) const;
21882 
21886  bool ShowCameraScale(bool & out_state) const;
21887 
21891  bool ShowCameraTranslation(bool & out_state) const;
21892 
21896  bool ShowCameraPerspectiveScale(bool & out_state) const;
21897 
21901  bool ShowCameraProjection(bool & out_state) const;
21902 
21906  bool ShowCameraOffset(bool & out_state) const;
21907 
21911  bool ShowCameraNearLimit(bool & out_state) const;
21912 
21916  bool ShowModellingMatrixRotation(bool & out_state) const;
21917 
21921  bool ShowModellingMatrixScale(bool & out_state) const;
21922 
21926  bool ShowModellingMatrixTranslation(bool & out_state) const;
21927 
21931  bool ShowModellingMatrixOffset(bool & out_state) const;
21932 
21933 private:
21936 };
21937 
21938 
21939 
21941 class HPS_API VisualEffectsKit : public Kit
21942 {
21943 public:
21944 
21946  VisualEffectsKit();
21947 
21950  VisualEffectsKit(VisualEffectsKit const & in_kit);
21951 
21955  VisualEffectsKit(VisualEffectsKit && in_that);
21956 
21960  VisualEffectsKit & operator=(VisualEffectsKit && in_that);
21961 
21963  virtual ~VisualEffectsKit();
21964 
21965  static const HPS::Type staticType = HPS::Type::VisualEffectsKit;
21966  HPS::Type ObjectType() const {return staticType;};
21967 
21971  static VisualEffectsKit GetDefault();
21972 
21975  void Set(VisualEffectsKit const & in_kit);
21976 
21979  void Show(VisualEffectsKit & out_kit) const;
21980 
21984  VisualEffectsKit & operator=(VisualEffectsKit const & in_kit);
21985 
21988  bool Empty() const;
21989 
21993  bool Equals(VisualEffectsKit const & in_kit) const;
21994 
21998  bool operator==(VisualEffectsKit const & in_kit) const;
21999 
22003  bool operator!=(VisualEffectsKit const & in_kit) const;
22004 
22008  VisualEffectsKit & SetPostProcessEffectsEnabled(bool in_state);
22009 
22013  VisualEffectsKit & SetAmbientOcclusionEnabled(bool in_state);
22014 
22018  VisualEffectsKit & SetBloomEnabled(bool in_state);
22019 
22023  VisualEffectsKit & SetDepthOfFieldEnabled(bool in_state);
22024 
22028  VisualEffectsKit & SetSilhouetteEdgesEnabled(bool in_state);
22029 
22033  VisualEffectsKit & SetEyeDomeLightingEnabled(bool in_state);
22034 
22040  VisualEffectsKit & SetEyeDomeLightingBackColor(bool in_state, RGBColor const & in_color = RGBColor::Black());
22041 
22046  VisualEffectsKit & SetEyeDomeLightingBackColor(RGBColor const & in_color);
22047 
22051  VisualEffectsKit & SetAntiAliasing(bool in_state);
22052 
22062  VisualEffectsKit & SetShadowMaps(bool in_state, unsigned int in_samples = 4, unsigned int in_resolution = 1024, bool in_view_dependent = true, bool in_jitter = true);
22063 
22072  VisualEffectsKit & SetShadowMaps(unsigned int in_samples, unsigned int in_resolution, bool in_view_dependent, bool in_jitter);
22073 
22080  VisualEffectsKit & SetSimpleShadow(bool in_state, unsigned int in_resolution = 256, unsigned int in_blurring = 1, bool in_ignore_transparency = false);
22081 
22087  VisualEffectsKit & SetSimpleShadow(unsigned int in_resolution, unsigned int in_blurring, bool in_ignore_transparency);
22088 
22092  VisualEffectsKit & SetSimpleShadowPlane(Plane const & in_projected_onto = Plane(0.0f, 1.0f, 0.0f, 1.0f));
22093 
22097  VisualEffectsKit & SetSimpleShadowLightDirection(Vector const & in_direction = Vector(0.0f, 1.0f, 0.0f));
22098 
22102  VisualEffectsKit & SetSimpleShadowColor(RGBAColor const & in_color = RGBAColor(0.0f, 0.0f, 0.0f, 1.0f));
22103 
22114  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);
22115 
22125  VisualEffectsKit & SetSimpleReflection(float in_opacity, unsigned int in_blurring, bool in_fading, float in_attenuation_near_distance, float in_attenuation_far_distance);
22126 
22130  VisualEffectsKit & SetSimpleReflectionPlane(Plane const & in_projected_onto = Plane(0.0f, 1.0f, 0.0f, 1.0f));
22131 
22135  VisualEffectsKit & SetSimpleReflectionVisibility(VisibilityKit const & in_reflected_types);
22136 
22139  VisualEffectsKit & UnsetPostProcessEffectsEnabled();
22140 
22143  VisualEffectsKit & UnsetAmbientOcclusionEnabled();
22144 
22147  VisualEffectsKit & UnsetSilhouetteEdgesEnabled();
22148 
22151  VisualEffectsKit & UnsetDepthOfFieldEnabled();
22152 
22155  VisualEffectsKit & UnsetBloomEnabled();
22156 
22159  VisualEffectsKit & UnsetEyeDomeLightingEnabled();
22160 
22163  VisualEffectsKit & UnsetEyeDomeLightingBackColor();
22164 
22167  VisualEffectsKit & UnsetAntiAliasing();
22168 
22171  VisualEffectsKit & UnsetShadowMaps();
22172 
22175  VisualEffectsKit & UnsetSimpleShadow();
22176 
22179  VisualEffectsKit & UnsetSimpleShadowPlane();
22180 
22183  VisualEffectsKit & UnsetSimpleShadowLightDirection();
22184 
22187  VisualEffectsKit & UnsetSimpleShadowColor();
22188 
22191  VisualEffectsKit & UnsetSimpleReflection();
22192 
22195  VisualEffectsKit & UnsetSimpleReflectionPlane();
22196 
22199  VisualEffectsKit & UnsetSimpleReflectionVisibility();
22200 
22203  VisualEffectsKit & UnsetEverything();
22204 
22208  bool ShowPostProcessEffectsEnabled(bool & out_state) const;
22209 
22213  bool ShowAmbientOcclusionEnabled(bool & out_state) const;
22214 
22218  bool ShowSilhouetteEdgesEnabled(bool & out_state) const;
22219 
22223  bool ShowDepthOfFieldEnabled(bool & out_state) const;
22224 
22228  bool ShowBloomEnabled(bool & out_state) const;
22229 
22233  bool ShowEyeDomeLightingEnabled(bool & out_state) const;
22234 
22239  bool ShowEyeDomeLightingBackColor(bool & out_state, RGBColor & out_color) const;
22240 
22244  bool ShowAntiAliasing(bool & out_state) const;
22245 
22253  bool ShowShadowMaps(bool & out_state, unsigned int & out_samples, unsigned int & out_resolution, bool & out_view_dependent, bool & out_jitter) const;
22254 
22261  bool ShowSimpleShadow(bool & out_state, unsigned int & out_resolution, unsigned int & out_blurring, bool & out_ignore_transparency) const;
22262 
22266  bool ShowSimpleShadowPlane(Plane & out_projected_onto) const;
22267 
22271  bool ShowSimpleShadowLightDirection(Vector & out_direction) const;
22272 
22276  bool ShowSimpleShadowColor(RGBAColor & out_color) const;
22277 
22286  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;
22287 
22288 
22292  bool ShowSimpleReflectionPlane(Plane & out_projected_onto) const;
22293 
22297  bool ShowSimpleReflectionVisibility(VisibilityKit & out_reflected_types) const;
22298 };
22299 
22300 
22306 class HPS_API VisualEffectsControl : public Control
22307 {
22308 public:
22309 
22311  explicit VisualEffectsControl(SegmentKey & in_seg);
22312 
22314  VisualEffectsControl(VisualEffectsControl const & in_that);
22315 
22320 
22324  VisualEffectsControl & operator=(VisualEffectsControl && in_that);
22325 
22328 
22329  virtual HPS::Type Type() const { return ObjectType(); }
22330 
22331  static const HPS::Type staticType = HPS::Type::VisualEffectsControl;
22332  HPS::Type ObjectType() const {return staticType;};
22333 
22337  VisualEffectsControl & operator=(VisualEffectsControl const & in_that);
22338 
22342  VisualEffectsControl & SetPostProcessEffectsEnabled(bool in_state);
22343 
22347  VisualEffectsControl & SetAmbientOcclusionEnabled(bool in_state);
22348 
22352  VisualEffectsControl & SetSilhouetteEdgesEnabled(bool in_state);
22353 
22357  VisualEffectsControl & SetDepthOfFieldEnabled(bool in_state);
22358 
22362  VisualEffectsControl & SetBloomEnabled(bool in_state);
22363 
22367  VisualEffectsControl & SetEyeDomeLightingEnabled(bool in_state);
22368 
22374  VisualEffectsControl & SetEyeDomeLightingBackColor(bool in_state, RGBColor const & in_color = RGBColor::Black());
22375 
22380  VisualEffectsControl & SetEyeDomeLightingBackColor(RGBColor const & in_color);
22381 
22385  VisualEffectsControl & SetAntiAliasing(bool in_state);
22386 
22396  VisualEffectsControl & SetShadowMaps(bool in_state, unsigned int in_samples = 4, unsigned int in_resolution = 1024, bool in_view_dependent = true, bool in_jitter = true);
22397 
22406  VisualEffectsControl & SetShadowMaps(unsigned int in_samples, unsigned int in_resolution, bool in_view_dependent, bool in_jitter);
22407 
22414  VisualEffectsControl & SetSimpleShadow(bool in_state, unsigned int in_resolution = 256, unsigned int in_blurring = 1, bool in_ignore_transparency = false);
22415 
22421  VisualEffectsControl & SetSimpleShadow(unsigned int in_resolution, unsigned int in_blurring, bool in_ignore_transparency);
22422 
22426  VisualEffectsControl & SetSimpleShadowPlane(Plane const & in_projected_onto = Plane(0.0f, 1.0f, 0.0f, 1.0f));
22427 
22431  VisualEffectsControl & SetSimpleShadowLightDirection(Vector const & in_direction = Vector(0.0f, 1.0f, 0.0f));
22432 
22436  VisualEffectsControl & SetSimpleShadowColor(RGBAColor const & in_color = RGBAColor(0.0f, 0.0f, 0.0f, 1.0f));
22437 
22448  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);
22449 
22459  VisualEffectsControl & SetSimpleReflection(float in_opacity, unsigned int in_blurring, bool in_fading, float in_attenuation_near_distance, float in_attenuation_far_distance);
22460 
22464  VisualEffectsControl & SetSimpleReflectionPlane(Plane const & in_projected_onto = Plane(0.0f, 1.0f, 0.0f, 1.0f));
22465 
22469  VisualEffectsControl & SetSimpleReflectionVisibility(VisibilityKit const & in_reflected_types);
22470 
22471 
22475  VisualEffectsControl & UnsetPostProcessEffectsEnabled();
22476 
22480  VisualEffectsControl & UnsetAmbientOcclusionEnabled();
22481 
22485  VisualEffectsControl & UnsetSilhouetteEdgesEnabled();
22486 
22490  VisualEffectsControl & UnsetDepthOfFieldEnabled();
22491 
22495  VisualEffectsControl & UnsetBloomEnabled();
22496 
22500  VisualEffectsControl & UnsetEyeDomeLightingEnabled();
22501 
22505  VisualEffectsControl & UnsetEyeDomeLightingBackColor();
22506 
22510  VisualEffectsControl & UnsetAntiAliasing();
22511 
22515  VisualEffectsControl & UnsetShadowMaps();
22516 
22520  VisualEffectsControl & UnsetSimpleShadow();
22521 
22525  VisualEffectsControl & UnsetSimpleShadowPlane();
22526 
22530  VisualEffectsControl & UnsetSimpleShadowLightDirection();
22531 
22535  VisualEffectsControl & UnsetSimpleShadowColor();
22536 
22540  VisualEffectsControl & UnsetSimpleReflection();
22541 
22545  VisualEffectsControl & UnsetSimpleReflectionPlane();
22546 
22550  VisualEffectsControl & UnsetSimpleReflectionVisibility();
22551 
22555  VisualEffectsControl & UnsetEverything();
22556 
22557 
22561  bool ShowPostProcessEffectsEnabled(bool & out_state) const;
22562 
22566  bool ShowAmbientOcclusionEnabled(bool & out_state) const;
22567 
22571  bool ShowSilhouetteEdgesEnabled(bool & out_state) const;
22572 
22576  bool ShowDepthOfFieldEnabled(bool & out_state) const;
22577 
22581  bool ShowBloomEnabled(bool & out_state) const;
22582 
22586  bool ShowEyeDomeLightingEnabled(bool & out_state) const;
22587 
22592  bool ShowEyeDomeLightingBackColor(bool & out_state, RGBColor & out_color) const;
22593 
22597  bool ShowAntiAliasing(bool & out_state) const;
22598 
22606  bool ShowShadowMaps(bool & out_state, unsigned int & out_samples, unsigned int & out_resolution, bool & out_view_dependent, bool & out_jitter) const;
22607 
22614  bool ShowSimpleShadow(bool & out_state, unsigned int & out_resolution, unsigned int & out_blurring, bool & out_ignore_transparency) const;
22615 
22619  bool ShowSimpleShadowPlane(Plane & out_projected_onto) const;
22620 
22624  bool ShowSimpleShadowLightDirection(Vector & out_direction) const;
22625 
22629  bool ShowSimpleShadowColor(RGBAColor & out_color) const;
22630 
22639  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;
22640 
22644  bool ShowSimpleReflectionPlane(Plane & out_projected_onto) const;
22645 
22649  bool ShowSimpleReflectionVisibility(VisibilityKit & out_reflected_types) const;
22650 
22651 private:
22654 };
22655 
22656 
22657 
22659 class HPS_API ContourLineKit : public Kit
22660 {
22661 public:
22662 
22664  ContourLineKit();
22665 
22668  ContourLineKit(ContourLineKit const & in_kit);
22669 
22673  ContourLineKit(ContourLineKit && in_that);
22674 
22678  ContourLineKit & operator=(ContourLineKit && in_that);
22679 
22681  virtual ~ContourLineKit();
22682 
22683  static const HPS::Type staticType = HPS::Type::ContourLineKit;
22684  HPS::Type ObjectType() const { return staticType; };
22685 
22689  static ContourLineKit GetDefault();
22690 
22693  void Set(ContourLineKit const & in_kit);
22694 
22697  void Show(ContourLineKit & out_kit) const;
22698 
22702  ContourLineKit & operator=(ContourLineKit const & in_kit);
22703 
22706  bool Empty() const;
22707 
22711  bool Equals(ContourLineKit const & in_kit) const;
22712 
22716  bool operator==(ContourLineKit const & in_kit) const;
22717 
22721  bool operator!=(ContourLineKit const & in_kit) const;
22722 
22723 
22727  ContourLineKit & SetVisibility(bool in_state);
22728 
22733  ContourLineKit & SetPositions(float in_interval, float in_offset);
22734 
22738  ContourLineKit & SetPositions(FloatArray const & in_positions);
22739 
22744  ContourLineKit & SetPositions(size_t in_count, float const in_positions[]);
22745 
22749  ContourLineKit & SetColors(RGBColorArray const & in_colors);
22750 
22755  ContourLineKit & SetColors(size_t in_count, RGBColor const in_colors[]);
22756 
22760  ContourLineKit & SetColors(RGBColor const & in_color);
22761 
22765  ContourLineKit & SetPatterns(UTF8Array const & in_patterns);
22766 
22771  ContourLineKit & SetPatterns(size_t in_count, UTF8 const in_patterns[]);
22772 
22776  ContourLineKit & SetPatterns(char const * in_pattern);
22777 
22782  ContourLineKit & SetWeights(FloatArray const & in_weights, LineSizeUnitsArray const & in_units);
22783 
22789  ContourLineKit & SetWeights(size_t in_count, float const in_weights[], Line::SizeUnits const in_units[]);
22790 
22795  ContourLineKit & SetWeights(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
22796 
22800  ContourLineKit & SetLighting(bool in_state);
22801 
22802 
22805  ContourLineKit & UnsetVisibility();
22806 
22809  ContourLineKit & UnsetPositions();
22810 
22813  ContourLineKit & UnsetColors();
22814 
22817  ContourLineKit & UnsetPatterns();
22818 
22821  ContourLineKit & UnsetWeights();
22822 
22825  ContourLineKit & UnsetLighting();
22826 
22829  ContourLineKit & UnsetEverything();
22830 
22831 
22835  bool ShowVisibility(bool & out_state) const;
22836 
22842  bool ShowPositions(ContourLine::Mode & out_mode, FloatArray & out_positions) const;
22843 
22847  bool ShowColors(RGBColorArray & out_colors) const;
22848 
22852  bool ShowPatterns(UTF8Array & out_patterns) const;
22853 
22858  bool ShowWeights(FloatArray & out_weights, LineSizeUnitsArray & out_units) const;
22859 
22863  bool ShowLighting(bool & out_state) const;
22864 };
22865 
22869 class HPS_API ContourLineControl : public Control
22870 {
22871 public:
22872 
22874  explicit ContourLineControl(SegmentKey & in_seg);
22875 
22877  ContourLineControl(ContourLineControl const & in_that);
22878 
22883 
22887  ContourLineControl & operator=(ContourLineControl && in_that);
22888 
22890  ~ContourLineControl();
22891 
22892  virtual HPS::Type Type() const { return ObjectType(); }
22893 
22894  static const HPS::Type staticType = HPS::Type::ContourLineControl;
22895  HPS::Type ObjectType() const { return staticType; };
22896 
22900  ContourLineControl & operator=(ContourLineControl const & in_that);
22901 
22905  ContourLineControl & SetVisibility(bool in_state);
22906 
22911  ContourLineControl & SetPositions(float in_interval, float in_offset);
22912 
22916  ContourLineControl & SetPositions(FloatArray const & in_positions);
22917 
22922  ContourLineControl & SetPositions(size_t in_count, float const in_positions[]);
22923 
22927  ContourLineControl & SetColors(RGBColorArray const & in_colors);
22928 
22933  ContourLineControl & SetColors(size_t in_count, RGBColor const in_colors[]);
22934 
22938  ContourLineControl & SetColors(RGBColor const & in_rgb_color);
22939 
22943  ContourLineControl & SetPatterns(UTF8Array const & in_patterns);
22944 
22949  ContourLineControl & SetPatterns(size_t in_count, UTF8 const in_patterns[]);
22950 
22954  ContourLineControl & SetPatterns(char const * in_pattern);
22955 
22960  ContourLineControl & SetWeights(FloatArray const & in_weights, LineSizeUnitsArray const & in_units);
22961 
22967  ContourLineControl & SetWeights(size_t in_count, float const in_weights[], Line::SizeUnits const in_units[]);
22968 
22973  ContourLineControl & SetWeights(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
22974 
22978  ContourLineControl & SetLighting(bool in_state);
22979 
22980 
22984  ContourLineControl & UnsetVisibility();
22985 
22989  ContourLineControl & UnsetPositions();
22990 
22994  ContourLineControl & UnsetColors();
22995 
22999  ContourLineControl & UnsetPatterns();
23000 
23004  ContourLineControl & UnsetWeights();
23005 
23009  ContourLineControl & UnsetLighting();
23010 
23014  ContourLineControl & UnsetEverything();
23015 
23016 
23020  bool ShowVisibility(bool & out_state) const;
23021 
23027  bool ShowPositions(ContourLine::Mode & out_mode, FloatArray & out_positions) const;
23028 
23032  bool ShowColors(RGBColorArray & out_colors) const;
23033 
23037  bool ShowPatterns(UTF8Array & out_patterns) const;
23038 
23043  bool ShowWeights(FloatArray & out_weights, LineSizeUnitsArray & out_units) const;
23044 
23048  bool ShowLighting(bool & out_state) const;
23049 
23050 private:
23053 };
23054 
23055 
23056 
23058 class HPS_API SubwindowKit : public Kit
23059 {
23060 public:
23061 
23063  SubwindowKit();
23064 
23066  SubwindowKit(SubwindowKit const & in_kit);
23067 
23071  SubwindowKit(SubwindowKit && in_that);
23072 
23076  SubwindowKit & operator=(SubwindowKit && in_that);
23077 
23079  virtual ~SubwindowKit();
23080 
23081  static const HPS::Type staticType = HPS::Type::SubwindowKit;
23082  HPS::Type ObjectType() const {return staticType;}
23083 
23087  static SubwindowKit GetDefault();
23088 
23091  void Set(SubwindowKit const & in_kit);
23092 
23095  void Show(SubwindowKit & out_kit) const;
23096 
23100  SubwindowKit & operator=(SubwindowKit const & in_kit);
23101 
23104  bool Empty() const;
23105 
23109  bool Equals(SubwindowKit const & in_kit) const;
23110 
23114  bool operator==(SubwindowKit const & in_kit) const;
23115 
23119  bool operator!=(SubwindowKit const & in_kit) const;
23120 
23121 
23131  SubwindowKit & SetSubwindow(Rectangle const & in_subwindow_position, Subwindow::Type in_subwindow_type = Subwindow::Type::Standard);
23132 
23133 
23144  SubwindowKit & SetSubwindow(Rectangle const & in_subwindow_position, IntRectangle const & in_subwindow_offsets, Subwindow::Type in_subwindow_type = Subwindow::Type::Standard);
23145 
23146 
23153  SubwindowKit & SetBackground(Subwindow::Background in_bg_type, char const * in_definition_name = "");
23154 
23159  SubwindowKit & SetBorder(Subwindow::Border in_border_type);
23160 
23165  SubwindowKit & SetRenderingAlgorithm(Subwindow::RenderingAlgorithm in_hsra);
23166 
23172  SubwindowKit & SetModelCompareMode(bool in_state, SegmentKey const & in_source1 = SegmentKey(), SegmentKey const & in_source2 = SegmentKey());
23173 
23178  SubwindowKit & SetModelCompareMode(SegmentKey const & in_source1, SegmentKey const & in_source2);
23179 
23182  SubwindowKit & UnsetSubwindow();
23183 
23186  SubwindowKit & UnsetBackground();
23187 
23190  SubwindowKit & UnsetBorder();
23191 
23194  SubwindowKit & UnsetRenderingAlgorithm();
23195 
23198  SubwindowKit & UnsetModelCompareMode();
23199 
23202  SubwindowKit & UnsetEverything();
23203 
23209  bool ShowSubwindow(Rectangle & out_subwindow_position, IntRectangle & out_subwindow_offsets, Subwindow::Type & out_subwindow_type) const;
23210 
23215  bool ShowBackground(Subwindow::Background & out_bg_type, UTF8 & out_definition_name) const;
23216 
23220  bool ShowBorder(Subwindow::Border & out_border_type) const;
23221 
23225  bool ShowRenderingAlgorithm(Subwindow::RenderingAlgorithm & out_hsra) const;
23226 
23232  bool ShowModelCompareMode(bool & out_state, SegmentKey & out_source1, SegmentKey & out_source2) const;
23233 };
23234 
23235 
23236 
23242 class HPS_API SubwindowControl : public Control
23243 {
23244 public:
23245 
23247  explicit SubwindowControl(SegmentKey & in_seg);
23248 
23250  SubwindowControl(SubwindowControl const & in_that);
23251 
23255  SubwindowControl(SubwindowControl && in_that);
23256 
23260  SubwindowControl & operator=(SubwindowControl && in_that);
23261 
23263  ~SubwindowControl();
23264 
23265  virtual HPS::Type Type() const { return ObjectType(); }
23266 
23267  static const HPS::Type staticType = HPS::Type::SubwindowControl;
23268  HPS::Type ObjectType() const {return staticType;}
23269 
23273  SubwindowControl & operator=(SubwindowControl const & in_that);
23274 
23285  SubwindowControl & SetSubwindow(Rectangle const & in_window_position, Subwindow::Type in_type = Subwindow::Type::Standard);
23286 
23298  SubwindowControl & SetSubwindow(Rectangle const & in_window_position, IntRectangle const & in_window_offsets, Subwindow::Type in_type = Subwindow::Type::Standard);
23299 
23306  SubwindowControl & SetBackground(Subwindow::Background in_bg_type, char const * in_definition_name = "");
23307 
23312  SubwindowControl & SetBorder(Subwindow::Border in_border_type);
23313 
23319  SubwindowControl & SetRenderingAlgorithm(Subwindow::RenderingAlgorithm in_hsra);
23320 
23326  SubwindowControl & SetModelCompareMode(bool in_state, SegmentKey const & in_source1 = SegmentKey(), SegmentKey const & in_source2 = SegmentKey());
23327 
23332  SubwindowControl & SetModelCompareMode(SegmentKey const & in_source1, SegmentKey const & in_source2);
23333 
23337  SubwindowControl & UnsetSubwindow();
23338 
23342  SubwindowControl & UnsetBackground();
23343 
23347  SubwindowControl & UnsetBorder();
23348 
23352  SubwindowControl & UnsetRenderingAlgorithm();
23353 
23357  SubwindowControl & UnsetModelCompareMode();
23358 
23362  SubwindowControl & UnsetEverything();
23363 
23369  bool ShowSubwindow(Rectangle & out_subwindow_position, IntRectangle & out_subwindow_offsets, Subwindow::Type & out_subwindow_type) const;
23370 
23375  bool ShowBackground(Subwindow::Background & out_bg_type, UTF8 & out_definition_name) const;
23376 
23380  bool ShowBorder(Subwindow::Border & out_border_type) const;
23381 
23385  bool ShowRenderingAlgorithm(Subwindow::RenderingAlgorithm & out_hsra) const;
23386 
23392  bool ShowModelCompareMode(bool & out_state, SegmentKey & out_source1, SegmentKey & out_source2) const;
23393 
23394 private:
23396  SubwindowControl();
23397 };
23398 
23399 
23400 
23402 class HPS_API DebuggingKit : public Kit
23403 {
23404 public:
23405 
23407  DebuggingKit();
23408 
23410  DebuggingKit(DebuggingKit const & in_kit);
23411 
23415  DebuggingKit(DebuggingKit && in_that);
23416 
23420  DebuggingKit & operator=(DebuggingKit && in_that);
23421 
23423  virtual ~DebuggingKit();
23424 
23425  static const HPS::Type staticType = HPS::Type::DebuggingKit;
23426  HPS::Type ObjectType() const {return staticType;}
23427 
23431  static DebuggingKit GetDefault();
23432 
23435  void Set(DebuggingKit const & in_kit);
23436 
23439  void Show(DebuggingKit & out_kit) const;
23440 
23444  DebuggingKit & operator=(DebuggingKit const & in_kit);
23445 
23448  bool Empty() const;
23449 
23453  bool Equals(DebuggingKit const & in_kit) const;
23454 
23458  bool operator==(DebuggingKit const & in_kit) const;
23459 
23463  bool operator!=(DebuggingKit const & in_kit) const;
23464 
23465 
23468  DebuggingKit & UnsetEverything();
23469 
23470 
23474  DebuggingKit & SetResourceMonitor(bool in_display);
23475 
23476 
23479  DebuggingKit & UnsetResourceMonitor();
23480 
23484  bool ShowResourceMonitor(bool & out_display) const;
23485 };
23486 
23487 
23490 class HPS_API DebuggingControl : public Control
23491 {
23492 public:
23493 
23495  explicit DebuggingControl(WindowKey & in_window);
23496 
23498  DebuggingControl(DebuggingControl const & in_that);
23499 
23503  DebuggingControl(DebuggingControl && in_that);
23504 
23508  DebuggingControl & operator=(DebuggingControl && in_that);
23509 
23511  ~DebuggingControl();
23512 
23513  virtual HPS::Type Type() const { return ObjectType(); }
23514 
23515  static const HPS::Type staticType = HPS::Type::DebuggingControl;
23516  HPS::Type ObjectType() const {return staticType;}
23517 
23521  DebuggingControl & operator=(DebuggingControl const & in_that);
23522 
23527  DebuggingControl & SetResourceMonitor(bool in_display);
23528 
23532  DebuggingControl & UnsetResourceMonitor();
23533 
23537  DebuggingControl & UnsetEverything();
23538 
23542  bool ShowResourceMonitor(bool & out_display) const;
23543 
23544 private:
23546  DebuggingControl();
23547 };
23548 
23549 
23551 class HPS_API WindowInfoKit : public Kit
23552 {
23553 public:
23554 
23556  WindowInfoKit();
23557 
23559  WindowInfoKit(WindowInfoKit const & in_kit);
23560 
23564  WindowInfoKit(WindowInfoKit && in_that);
23565 
23569  WindowInfoKit & operator=(WindowInfoKit && in_that);
23570 
23572  virtual ~WindowInfoKit();
23573 
23574  static const HPS::Type staticType = HPS::Type::WindowInfoKit;
23575  HPS::Type ObjectType() const {return staticType;}
23576 
23579  void Set(WindowInfoKit const & in_kit);
23580 
23583  void Show(WindowInfoKit & out_kit) const;
23584 
23588  WindowInfoKit & operator=(WindowInfoKit const & in_kit);
23589 
23592  bool Empty() const;
23593 
23597  bool Equals(WindowInfoKit const & in_kit) const;
23598 
23602  bool operator==(WindowInfoKit const & in_kit) const;
23603 
23607  bool operator!=(WindowInfoKit const & in_kit) const;
23608 
23609 
23614  WindowInfoKit & SetPhysicalPixels(unsigned int in_width, unsigned int in_height);
23615 
23620  WindowInfoKit & SetPhysicalSize(float in_width, float in_height);
23621 
23626  WindowInfoKit & SetWindowPixels(unsigned int in_width, unsigned int in_height);
23627 
23632  WindowInfoKit & SetWindowSize(float in_width, float in_height);
23633 
23634 
23637  WindowInfoKit & UnsetPhysicalPixels();
23638 
23641  WindowInfoKit & UnsetPhysicalSize();
23642 
23645  WindowInfoKit & UnsetWindowPixels();
23646 
23649  WindowInfoKit & UnsetWindowSize();
23650 
23653  WindowInfoKit & UnsetEverything();
23654 
23655 
23660  bool ShowPhysicalPixels(unsigned int & out_width, unsigned int & out_height) const;
23661 
23666  bool ShowPhysicalSize(float & out_width, float & out_height) const;
23667 
23672  bool ShowWindowPixels(unsigned int & out_width, unsigned int & out_height) const;
23673 
23678  bool ShowWindowSize(float & out_width, float & out_height) const;
23679 
23685  bool ShowResolution(float & out_horizontal, float & out_vertical) const;
23686 
23690  bool ShowWindowAspectRatio(float & out_window_aspect) const;
23691 
23695  bool ShowPixelAspectRatio(float & out_pixel_aspect) const;
23696 };
23697 
23698 
23701 class HPS_API WindowInfoControl : public Control
23702 {
23703 public:
23704 
23706  explicit WindowInfoControl(WindowKey & in_window);
23707 
23709  WindowInfoControl(WindowInfoControl const & in_that);
23710 
23715 
23719  WindowInfoControl & operator=(WindowInfoControl && in_that);
23720 
23722  ~WindowInfoControl();
23723 
23724  virtual HPS::Type Type() const { return ObjectType(); }
23725 
23726  static const HPS::Type staticType = HPS::Type::WindowInfoControl;
23727  HPS::Type ObjectType() const {return staticType;}
23728 
23732  WindowInfoControl & operator=(WindowInfoControl const & in_that);
23733 
23738  bool ShowPhysicalPixels(unsigned int & out_width, unsigned int & out_height) const;
23739 
23744  bool ShowPhysicalSize(float & out_width, float & out_height) const;
23745 
23750  bool ShowWindowPixels(unsigned int & out_width, unsigned int & out_height) const;
23751 
23756  bool ShowWindowSize(float & out_width, float & out_height) const;
23757 
23763  bool ShowResolution(float & out_horizontal, float & out_vertical) const;
23764 
23768  bool ShowWindowAspectRatio(float & out_window_aspect) const;
23769 
23773  bool ShowPixelAspectRatio(float & out_pixel_aspect) const;
23774 
23779  bool ShowMaxTextureSize(unsigned int & out_width, unsigned int & out_height) const;
23780 
23785  bool ShowLastUpdateTime(Time & out_time) const;
23786 
23790  bool ShowDepthPeelingLayers(size_t & out_layers) const;
23791 
23795  bool ShowVideoMemory(size_t & out_video_memory) const;
23796 
23800  bool ShowDepthBufferSize(size_t & out_bits) const;
23801 
23805  bool ShowMaxLights(size_t & out_lights) const;
23806 
23810  bool ShowColorBitPlanes(size_t & out_planes) const;
23811 
23815  bool ShowLastUpdateInfo(UpdateInfo & out_info) const;
23816 
23820  bool ShowGPUName(UTF8 & out_name) const;
23821 
23822 private:
23825 };
23826 
23828 class HPS_API FontInfoState : public Object
23829 {
23830 public:
23831 
23833  FontInfoState();
23834 
23836  FontInfoState(FontInfoState const & in_kit);
23837 
23841  FontInfoState(FontInfoState && in_that);
23842 
23846  FontInfoState & operator=(FontInfoState && in_that);
23847 
23849  virtual ~FontInfoState();
23850 
23851  static const HPS::Type staticType = HPS::Type::FontInfoState;
23852  HPS::Type ObjectType() const {return staticType;}
23853 
23856  void Assign(FontInfoState const & in_that);
23857 
23860  void Set(FontInfoState const & in_kit);
23861 
23864  void Show(FontInfoState & out_kit) const;
23865 
23869  FontInfoState & operator=(FontInfoState const & in_kit);
23870 
23873  bool Empty() const;
23874 
23878  bool Equals(FontInfoState const & in_kit) const;
23879 
23883  bool operator==(FontInfoState const & in_kit) const;
23884 
23888  bool operator!=(FontInfoState const & in_kit) const;
23889 
23892  UTF8 GetName() const;
23893 
23896  bool ShowSystemName(HPS::UTF8 & out_name) const;
23897 
23900  bool GetShellConvertibility() const;
23901 };
23902 
23903 
23908 class HPS_API AttributeLockKit : public Kit
23909 {
23910 public:
23911 
23913  AttributeLockKit();
23914 
23916  AttributeLockKit(AttributeLockKit const & in_kit);
23917 
23921  AttributeLockKit(AttributeLockKit && in_that);
23922 
23926  AttributeLockKit & operator=(AttributeLockKit && in_that);
23927 
23929  virtual ~AttributeLockKit();
23930 
23931  static const HPS::Type staticType = HPS::Type::AttributeLockKit;
23932  HPS::Type ObjectType() const {return staticType;}
23933 
23937  static AttributeLockKit GetDefault();
23938 
23941  void Set(AttributeLockKit const & in_kit);
23942 
23945  void Show(AttributeLockKit & out_kit) const;
23946 
23950  AttributeLockKit & operator=(AttributeLockKit const & in_kit);
23951 
23954  bool Empty() const;
23955 
23959  bool Equals(AttributeLockKit const & in_kit) const;
23960 
23964  bool operator==(AttributeLockKit const & in_kit) const;
23965 
23969  bool operator!=(AttributeLockKit const & in_kit) const;
23970 
23976  AttributeLockKit & SetLock(AttributeLock::Type in_type, bool in_state = true);
23977 
23982  AttributeLockKit & SetLock(AttributeLockTypeArray const & in_types, BoolArray const & in_states);
23983 
23989  AttributeLockKit & SetSubsegmentLockOverride(AttributeLock::Type in_type, bool in_state = true);
23990 
23996  AttributeLockKit & SetSubsegmentLockOverride(AttributeLockTypeArray const & in_types, BoolArray const & in_states);
23997 
23998 
24001  AttributeLockKit & UnsetLock(AttributeLock::Type in_type = AttributeLock::Type::Everything);
24002 
24005  AttributeLockKit & UnsetLock(AttributeLockTypeArray const & in_types);
24006 
24009  AttributeLockKit & UnsetSubsegmentLockOverride(AttributeLock::Type in_type = AttributeLock::Type::Everything);
24010 
24013  AttributeLockKit & UnsetSubsegmentLockOverride(AttributeLockTypeArray const & in_types);
24014 
24017  AttributeLockKit & UnsetEverything();
24018 
24019 
24024  bool ShowLock(AttributeLock::Type in_type, bool & out_state) const;
24025 
24030  bool ShowLock(AttributeLockTypeArray & out_types, BoolArray & out_states) const;
24031 
24036  bool ShowSubsegmentLockOverride(AttributeLock::Type in_type, bool & out_state) const;
24037 
24042  bool ShowSubsegmentLockOverride(AttributeLockTypeArray & out_types, BoolArray & out_states) const;
24043 };
24044 
24045 
24050 class HPS_API AttributeLockControl : public Control
24051 {
24052 public:
24053 
24055  explicit AttributeLockControl(SegmentKey & in_seg);
24056 
24061 
24065  AttributeLockControl & operator=(AttributeLockControl && in_that);
24066 
24068  AttributeLockControl(AttributeLockControl const & in_that);
24069 
24072 
24073  virtual HPS::Type Type() const { return ObjectType(); }
24074 
24075  static const HPS::Type staticType = HPS::Type::AttributeLockControl;
24076  HPS::Type ObjectType() const {return staticType;}
24077 
24081  AttributeLockControl & operator=(AttributeLockControl const & in_that);
24082 
24088  AttributeLockControl & SetLock(AttributeLock::Type in_type, bool in_state = true);
24089 
24094  AttributeLockControl & SetLock(AttributeLockTypeArray const & in_types, BoolArray const & in_states);
24095 
24101  AttributeLockControl & SetSubsegmentLockOverride(AttributeLock::Type in_type, bool in_state = true);
24102 
24108  AttributeLockControl & SetSubsegmentLockOverride(AttributeLockTypeArray const & in_types, BoolArray const & in_states);
24109 
24110 
24114  AttributeLockControl & UnsetLock(AttributeLock::Type in_type = AttributeLock::Type::Everything);
24115 
24119  AttributeLockControl & UnsetLock(AttributeLockTypeArray const & in_types);
24120 
24124  AttributeLockControl & UnsetSubsegmentLockOverride(AttributeLock::Type in_type = AttributeLock::Type::Everything);
24125 
24129  AttributeLockControl & UnsetSubsegmentLockOverride(AttributeLockTypeArray const & in_types);
24130 
24134  AttributeLockControl & UnsetEverything();
24135 
24136 
24141  bool ShowLock(AttributeLock::Type in_type, bool & out_state) const;
24142 
24147  bool ShowLock(AttributeLockTypeArray & out_types, BoolArray & out_states) const;
24148 
24153  bool ShowSubsegmentLockOverride(AttributeLock::Type in_type, bool & out_state) const;
24154 
24159  bool ShowSubsegmentLockOverride(AttributeLockTypeArray & out_types, BoolArray & out_states) const;
24160 
24161 private:
24164 };
24165 
24169 
24170 class HPS_API GeometryKey : public Key
24171 {
24172 public:
24174  GeometryKey();
24175 
24179  explicit GeometryKey(Key const & in_that);
24180 
24183  GeometryKey(GeometryKey const & in_that);
24184 
24188  GeometryKey & operator=(GeometryKey const & in_that);
24189 
24193  GeometryKey(GeometryKey && in_that);
24194 
24198  GeometryKey & operator=(GeometryKey && in_that);
24199 
24200  ~GeometryKey();
24201 
24202  static const HPS::Type staticType = HPS::Type::GeometryKey;
24203  HPS::Type ObjectType() const { return staticType; };
24204 
24205 
24209  size_t ShowReferrers(SegmentKeyArray & out_segments) const;
24210 
24214  size_t ShowReferrers(ReferenceKeyArray & out_references) const;
24215 
24216 
24217 
24224  GeometryKey & SetPriority(int in_priority);
24225 
24228  GeometryKey & UnsetPriority();
24229 
24233  bool ShowPriority(int & out_priority) const;
24234 
24235 
24241  GeometryKey & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
24242 
24247  GeometryKey & SetUserData(intptr_t in_index, ByteArray const & in_data);
24248 
24253  GeometryKey & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
24254 
24258  GeometryKey & UnsetUserData(intptr_t in_index);
24259 
24264  GeometryKey & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
24265 
24269  GeometryKey & UnsetUserData(IntPtrTArray const & in_indices);
24270 
24273  GeometryKey & UnsetAllUserData();
24274 
24276  size_t ShowUserDataCount() const;
24277 
24281  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
24282 
24287  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
24288 
24293  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
24294 
24299  bool ShowBounding(BoundingKit & out_kit) const;
24300 };
24301 
24302 
24304 class HPS_API LineKit : public Kit
24305 {
24306 public:
24308  LineKit();
24309 
24312  LineKit(LineKit const & in_kit);
24313 
24317  LineKit(LineKit && in_that);
24318 
24322  LineKit & operator=(LineKit && in_that);
24323 
24324  virtual ~LineKit();
24325 
24326  static const HPS::Type staticType = HPS::Type::LineKit;
24327  HPS::Type ObjectType() const { return staticType; };
24328 
24331  void Consume(LineKit & in_kit);
24332 
24335  void Set(LineKit const & in_kit);
24336 
24339  void Show(LineKit & out_kit) const;
24340 
24344  LineKit & operator=(LineKit const & in_kit);
24345 
24348  bool Empty() const;
24349 
24353  bool Equals(LineKit const & in_kit) const;
24354 
24358  bool operator==(LineKit const & in_kit) const;
24359 
24363  bool operator!=(LineKit const & in_kit) const;
24364 
24367  size_t GetPointCount() const;
24368 
24375  LineKit & SetPriority(int in_priority);
24376 
24379  LineKit & UnsetPriority();
24380 
24384  bool ShowPriority(int & out_priority) const;
24385 
24386 
24390  LineKit & SetPoints(PointArray const & in_points);
24391 
24396  LineKit & SetPoints(size_t in_count, Point const in_points []);
24397 
24398 
24401  LineKit & UnsetPoints();
24402 
24405  LineKit & UnsetEverything();
24406 
24407 
24411  bool ShowPoints(PointArray & out_points) const;
24412 
24418  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
24419 
24424  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
24425 
24431  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
24432 
24437  LineKit & SetPoints(PointArray const & in_points, LineCoordinateSpaceArray const & in_spaces);
24438 
24444  LineKit & SetPoints(size_t in_count, Point const in_points[], Line::CoordinateSpace const in_spaces[]);
24445 
24446 
24451  bool ShowPoints(PointArray & out_points, LineCoordinateSpaceArray & out_coordinate_spaces) const;
24452 
24458  LineKit & SetPointCoordinateSpace(size_t in_count, size_t const in_indices[], Line::CoordinateSpace const in_spaces[]);
24459 
24464  LineKit & SetPointCoordinateSpace(SizeTArray const & in_indices, LineCoordinateSpaceArray const & in_spaces);
24465 
24469  LineKit & SetPointCoordinateSpace(LineCoordinateSpaceArray const & in_spaces);
24470 
24475  LineKit & SetPointCoordinateSpace(size_t in_count, Line::CoordinateSpace const in_spaces[]);
24476 
24480  LineKit & UnsetPointCoordinateSpace(SizeTArray const & in_indices);
24481 
24486  LineKit & UnsetPointCoordinateSpace(size_t in_count, size_t const in_indices[]);
24487 
24490  LineKit & UnsetPointCoordinateSpace();
24491 
24497  bool ShowPointCoordinateSpace(size_t in_count, size_t const in_indices[], LineCoordinateSpaceArray & out_spaces) const;
24498 
24503  bool ShowPointCoordinateSpace(SizeTArray const & in_indices, LineCoordinateSpaceArray & out_spaces) const;
24504 
24508  bool ShowPointCoordinateSpace(LineCoordinateSpaceArray & out_spaces) const;
24509 
24515  LineKit & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
24516 
24521  LineKit & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
24522 
24527  LineKit & EditPointsByDeletion(size_t in_offset, size_t in_count);
24528 
24534  LineKit & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
24535 
24541  LineKit & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
24542 
24548  LineKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
24549 
24554  LineKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
24555 
24560  LineKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
24561 
24565  LineKit & UnsetUserData(intptr_t in_index);
24566 
24571  LineKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
24572 
24576  LineKit & UnsetUserData(IntPtrTArray const & in_indices);
24577 
24580  LineKit & UnsetAllUserData();
24581 
24583  size_t ShowUserDataCount() const;
24584 
24588  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
24589 
24594  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
24595 
24600  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
24601 };
24602 
24604 class HPS_API LineKey : public GeometryKey
24605 {
24606 public:
24608  LineKey();
24609 
24613  explicit LineKey(Key const & in_that);
24614 
24617  LineKey(LineKey const & in_that);
24618 
24622  LineKey & operator=(LineKey const & in_that);
24623 
24627  LineKey(LineKey && in_that);
24628 
24632  LineKey & operator=(LineKey && in_that);
24633 
24634  ~LineKey();
24635 
24636  static const HPS::Type staticType = HPS::Type::LineKey;
24637  HPS::Type ObjectType() const { return staticType; };
24638 
24639 
24642  void Consume(LineKit & in_kit);
24643 
24646  void Set(LineKit const & in_kit);
24647 
24650  void Show(LineKit & out_kit) const;
24651 
24654  size_t GetPointCount() const;
24655 
24659  LineKey & SetPoints(PointArray const & in_points);
24660 
24665  LineKey & SetPoints(size_t in_count, Point const in_points []);
24666 
24670  bool ShowPoints(PointArray & out_points) const;
24671 
24677  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
24678 
24683  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
24684 
24690  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
24691 
24696  LineKey & SetPoints(PointArray const & in_points, LineCoordinateSpaceArray const & in_spaces);
24697 
24703  LineKey & SetPoints(size_t in_count, Point const in_points[], Line::CoordinateSpace const in_spaces[]);
24704 
24705 
24710  bool ShowPoints(PointArray & out_points, LineCoordinateSpaceArray & out_coordinate_spaces) const;
24711 
24717  LineKey & SetPointCoordinateSpace(size_t in_count, size_t const in_indices[], Line::CoordinateSpace const in_spaces[]);
24718 
24723  LineKey & SetPointCoordinateSpace(SizeTArray const & in_indices, LineCoordinateSpaceArray const & in_spaces);
24724 
24728  LineKey & SetPointCoordinateSpace(LineCoordinateSpaceArray const & in_spaces);
24729 
24734  LineKey & SetPointCoordinateSpace(size_t in_count, Line::CoordinateSpace const in_spaces []);
24735 
24739  LineKey & UnsetPointCoordinateSpace(SizeTArray const & in_indices);
24740 
24745  LineKey & UnsetPointCoordinateSpace(size_t in_count, size_t const in_indices[]);
24746 
24749  LineKey & UnsetPointCoordinateSpace();
24750 
24756  bool ShowPointCoordinateSpace(size_t in_count, size_t const in_indices[], LineCoordinateSpaceArray & out_spaces) const;
24757 
24762  bool ShowPointCoordinateSpace(SizeTArray const & in_indices, LineCoordinateSpaceArray & out_spaces) const;
24763 
24767  bool ShowPointCoordinateSpace(LineCoordinateSpaceArray & out_spaces) const;
24768 
24774  LineKey & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
24775 
24780  LineKey & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
24781 
24786  LineKey & EditPointsByDeletion(size_t in_offset, size_t in_count);
24787 
24793  LineKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
24794 
24800  LineKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
24801 };
24802 
24803 
24804 
24806 class HPS_API MarkerKit : public Kit
24807 {
24808 public:
24810  MarkerKit();
24811 
24814  MarkerKit(MarkerKit const & in_kit);
24815 
24819  MarkerKit(MarkerKit && in_that);
24820 
24824  MarkerKit & operator=(MarkerKit && in_that);
24825 
24826  virtual ~MarkerKit();
24827 
24828  static const HPS::Type staticType = HPS::Type::MarkerKit;
24829  HPS::Type ObjectType() const { return staticType; };
24830 
24833  void Consume(MarkerKit & in_kit);
24834 
24837  void Set(MarkerKit const & in_kit);
24838 
24841  void Show(MarkerKit & out_kit) const;
24842 
24846  MarkerKit & operator=(MarkerKit const & in_kit);
24847 
24850  bool Empty() const;
24851 
24855  bool Equals(MarkerKit const & in_kit) const;
24856 
24860  bool operator==(MarkerKit const & in_kit) const;
24861 
24865  bool operator!=(MarkerKit const & in_kit) const;
24866 
24867 
24874  MarkerKit & SetPriority(int in_priority);
24875 
24878  MarkerKit & UnsetPriority();
24879 
24883  bool ShowPriority(int & out_priority) const;
24884 
24888  MarkerKit & SetPoint(Point const & in_point);
24889 
24890 
24893  MarkerKit & UnsetPoint();
24894 
24897  MarkerKit & UnsetEverything();
24898 
24899 
24903  bool ShowPoint(HPS::Point & out_point) const;
24904 
24910  MarkerKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
24911 
24916  MarkerKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
24917 
24922  MarkerKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
24923 
24927  MarkerKit & UnsetUserData(intptr_t in_index);
24928 
24933  MarkerKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
24934 
24938  MarkerKit & UnsetUserData(IntPtrTArray const & in_indices);
24939 
24942  MarkerKit & UnsetAllUserData();
24943 
24945  size_t ShowUserDataCount() const;
24946 
24950  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
24951 
24956  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
24957 
24962  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
24963 };
24964 
24966 class HPS_API MarkerKey : public GeometryKey
24967 {
24968 public:
24970  MarkerKey();
24971 
24975  explicit MarkerKey(Key const & in_that);
24976 
24979  MarkerKey(MarkerKey const & in_that);
24980 
24984  MarkerKey & operator=(MarkerKey const & in_that);
24985 
24989  MarkerKey(MarkerKey && in_that);
24990 
24994  MarkerKey & operator=(MarkerKey && in_that);
24995 
24996  ~MarkerKey();
24997 
24998  static const HPS::Type staticType = HPS::Type::MarkerKey;
24999  HPS::Type ObjectType() const { return staticType; };
25000 
25001 
25004  void Consume(MarkerKit & in_kit);
25005 
25008  void Set(MarkerKit const & in_kit);
25009 
25012  void Show(MarkerKit & out_kit) const;
25013 
25014 
25018  MarkerKey & SetPoint(Point const & in_point);
25019 
25023  bool ShowPoint(Point & out_point) const;
25024 };
25025 
25026 
25027 
25029 class HPS_API DistantLightKit : public Kit
25030 {
25031 public:
25033  DistantLightKit();
25034 
25037  DistantLightKit(DistantLightKit const & in_kit);
25038 
25042  DistantLightKit(DistantLightKit && in_that);
25043 
25047  DistantLightKit & operator=(DistantLightKit && in_that);
25048 
25049  virtual ~DistantLightKit();
25050 
25051  static const HPS::Type staticType = HPS::Type::DistantLightKit;
25052  HPS::Type ObjectType() const { return staticType; };
25053 
25056  void Consume(DistantLightKit & in_kit);
25057 
25060  void Set(DistantLightKit const & in_kit);
25061 
25064  void Show(DistantLightKit & out_kit) const;
25065 
25069  DistantLightKit & operator=(DistantLightKit const & in_kit);
25070 
25073  bool Empty() const;
25074 
25078  bool Equals(DistantLightKit const & in_kit) const;
25079 
25083  bool operator==(DistantLightKit const & in_kit) const;
25084 
25088  bool operator!=(DistantLightKit const & in_kit) const;
25089 
25090 
25097  DistantLightKit & SetPriority(int in_priority);
25098 
25104  DistantLightKit & SetDirection(HPS::Vector const & in_vector);
25105 
25109  DistantLightKit & SetColor(RGBAColor const & in_rgba_color);
25110 
25114  DistantLightKit & SetColorByIndex(float in_index);
25115 
25121  DistantLightKit & SetCameraRelative(bool in_state);
25122 
25123 
25126  DistantLightKit & UnsetPriority();
25127 
25130  DistantLightKit & UnsetDirection();
25131 
25134  DistantLightKit & UnsetColor();
25135 
25138  DistantLightKit & UnsetCameraRelative();
25139 
25142  DistantLightKit & UnsetEverything();
25143 
25144 
25148  bool ShowPriority(int & out_priority) const;
25149 
25153  bool ShowDirection(HPS::Vector & out_vector) const;
25154 
25160  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
25161 
25165  bool ShowCameraRelative(bool & out_state) const;
25166 
25172  DistantLightKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
25173 
25178  DistantLightKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
25179 
25184  DistantLightKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
25185 
25189  DistantLightKit & UnsetUserData(intptr_t in_index);
25190 
25195  DistantLightKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
25196 
25200  DistantLightKit & UnsetUserData(IntPtrTArray const & in_indices);
25201 
25204  DistantLightKit & UnsetAllUserData();
25205 
25207  size_t ShowUserDataCount() const;
25208 
25212  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
25213 
25218  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
25219 
25224  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
25225 };
25226 
25227 
25228 
25230 class HPS_API DistantLightKey : public GeometryKey
25231 {
25232 public:
25234  DistantLightKey();
25235 
25239  explicit DistantLightKey(Key const & in_that);
25240 
25243  DistantLightKey(DistantLightKey const & in_that);
25244 
25248  DistantLightKey & operator=(DistantLightKey const & in_that);
25249 
25253  DistantLightKey(DistantLightKey && in_that);
25254 
25258  DistantLightKey & operator=(DistantLightKey && in_that);
25259 
25260  ~DistantLightKey();
25261 
25262  static const HPS::Type staticType = HPS::Type::DistantLightKey;
25263  HPS::Type ObjectType() const { return staticType; };
25264 
25267  void Consume(DistantLightKit & in_kit);
25268 
25271  void Set(DistantLightKit const & in_kit);
25272 
25275  void Show(DistantLightKit & out_kit) const;
25276 
25281  DistantLightKey & SetDirection(HPS::Vector const & in_vector);
25282 
25286  DistantLightKey & SetColor(RGBAColor const & in_rgba_color);
25287 
25291  DistantLightKey & SetColorByIndex(float in_index);
25292 
25297  DistantLightKey & SetCameraRelative(bool in_state);
25298 
25299 
25302  DistantLightKey & UnsetColor();
25303 
25304 
25308  bool ShowDirection(HPS::Vector & out_vector) const;
25309 
25315  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
25316 
25320  bool ShowCameraRelative(bool & out_state) const;
25321 };
25322 
25323 
25324 
25325 
25327 class HPS_API CylinderKit : public Kit
25328 {
25329 public:
25331  CylinderKit();
25332 
25335  CylinderKit(CylinderKit const & in_kit);
25336 
25340  CylinderKit(CylinderKit && in_that);
25341 
25345  CylinderKit & operator=(CylinderKit && in_that);
25346 
25347  virtual ~CylinderKit();
25348 
25349  static const HPS::Type staticType = HPS::Type::CylinderKit;
25350  HPS::Type ObjectType() const { return staticType; };
25351 
25354  void Consume(CylinderKit & in_kit);
25355 
25358  void Set(CylinderKit const & in_kit);
25359 
25362  void Show(CylinderKit & out_kit) const;
25363 
25367  CylinderKit & operator=(CylinderKit const & in_kit);
25368 
25371  bool Empty() const;
25372 
25376  bool Equals(CylinderKit const & in_kit) const;
25377 
25381  bool operator==(CylinderKit const & in_kit) const;
25382 
25386  bool operator!=(CylinderKit const & in_kit) const;
25387 
25390  size_t GetPointCount() const;
25391 
25398  CylinderKit & SetPriority(int in_priority);
25399 
25402  CylinderKit & UnsetPriority();
25403 
25407  bool ShowPriority(int & out_priority) const;
25408 
25409 
25413  CylinderKit & SetPoints(PointArray const & in_points);
25414 
25419  CylinderKit & SetPoints(size_t in_count, Point const in_points []);
25420 
25424  CylinderKit & SetRadii(FloatArray const & in_radii);
25425 
25430  CylinderKit & SetRadii(size_t in_count, float const in_radii []);
25431 
25435  CylinderKit & SetCaps(Cylinder::Capping in_capping);
25436 
25437 
25440  CylinderKit & UnsetPoints();
25441 
25444  CylinderKit & UnsetRadii();
25445 
25448  CylinderKit & UnsetCaps();
25449 
25452  CylinderKit & UnsetEverything();
25453 
25454 
25458  bool ShowPoints(PointArray & out_points) const;
25459 
25465  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
25466 
25471  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
25472 
25478  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
25479 
25483  bool ShowRadii(FloatArray & out_radii) const;
25484 
25488  bool ShowCaps(Cylinder::Capping & out_caps) const;
25489 
25490 
25497  CylinderKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
25498 
25504  CylinderKit & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
25505 
25512  CylinderKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
25513 
25520  CylinderKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
25521 
25528  CylinderKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
25529 
25536  CylinderKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
25537 
25543  CylinderKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
25544 
25545 
25552  CylinderKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
25553 
25559  CylinderKit & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
25560 
25567  CylinderKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
25568 
25575  CylinderKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
25576 
25583  CylinderKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
25584 
25591  CylinderKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
25592 
25598  CylinderKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
25599 
25600 
25603  CylinderKit & UnsetVertexColors();
25604 
25609  CylinderKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
25610 
25614  CylinderKit & UnsetVertexColorsByList(SizeTArray const & in_vertices);
25615 
25616 
25620  CylinderKit & UnsetVertexColors(Cylinder::Component in_apply_to);
25621 
25627  CylinderKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Cylinder::Component in_apply_to);
25628 
25633  CylinderKit & UnsetVertexColorsByList(SizeTArray const & in_vertices, Cylinder::Component in_apply_to);
25634 
25639  CylinderKit & UnsetVertexColorsByList(size_t in_count, size_t const in_vertices[]);
25640 
25646  CylinderKit & UnsetVertexColorsByList(size_t in_count, size_t const in_vertices[], Cylinder::Component in_apply_to);
25647 
25657  bool ShowVertexColors(Cylinder::Component in_apply_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
25658 
25670  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;
25671 
25684  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Cylinder::Component in_apply_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
25685 
25691  CylinderKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
25692 
25697  CylinderKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
25698 
25703  CylinderKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
25704 
25708  CylinderKit & UnsetUserData(intptr_t in_index);
25709 
25714  CylinderKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
25715 
25719  CylinderKit & UnsetUserData(IntPtrTArray const & in_indices);
25720 
25723  CylinderKit & UnsetAllUserData();
25724 
25726  size_t ShowUserDataCount() const;
25727 
25731  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
25732 
25737  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
25738 
25743  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
25744 };
25745 
25746 
25747 
25749 class HPS_API CylinderKey : public GeometryKey
25750 {
25751 public:
25753  CylinderKey();
25754 
25758  explicit CylinderKey(Key const & in_that);
25759 
25762  CylinderKey(CylinderKey const & in_that);
25763 
25767  CylinderKey & operator=(CylinderKey const & in_that);
25768 
25772  CylinderKey(CylinderKey && in_that);
25773 
25777  CylinderKey & operator=(CylinderKey && in_that);
25778 
25779  ~CylinderKey();
25780 
25781  static const HPS::Type staticType = HPS::Type::CylinderKey;
25782  HPS::Type ObjectType() const { return staticType; };
25783 
25786  void Consume(CylinderKit & in_kit);
25787 
25790  void Set(CylinderKit const & in_kit);
25791 
25792 
25798  CylinderKey & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
25799 
25804  CylinderKey & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
25805 
25810  CylinderKey & EditPointsByDeletion(size_t in_offset, size_t in_count);
25811 
25817  CylinderKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
25818 
25824  CylinderKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
25825 
25826 
25832  CylinderKey & EditRadiiByInsertion(size_t in_offset, size_t in_count, float const in_radii[]);
25833 
25838  CylinderKey & EditRadiiByInsertion(size_t in_offset, FloatArray const & in_radii);
25839 
25844  CylinderKey & EditRadiiByDeletion(size_t in_offset, size_t in_count);
25845 
25851  CylinderKey & EditRadiiByReplacement(size_t in_offset, size_t in_count, float const in_radii[]);
25852 
25858  CylinderKey & EditRadiiByReplacement(size_t in_offset, FloatArray const & in_radii);
25859 
25860 
25863  void Show(CylinderKit & out_kit) const;
25864 
25867  size_t GetPointCount() const;
25868 
25872  bool ShowPoints(PointArray & out_points) const;
25873 
25879  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
25880 
25885  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
25886 
25892  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
25893 
25897  bool ShowRadii(FloatArray & out_radii) const;
25898 
25902  bool ShowCaps(Cylinder::Capping & out_caps) const;
25903 
25904 
25911  CylinderKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
25912 
25919  CylinderKey & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
25920 
25927  CylinderKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
25928 
25929 
25936  CylinderKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
25937 
25944  CylinderKey & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
25945 
25952  CylinderKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
25953 
25960  CylinderKey & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
25961 
25967  CylinderKey & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
25968 
25975  CylinderKey & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
25976 
25982  CylinderKey & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
25983 
25990  CylinderKey & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
25991 
25997  CylinderKey & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
25998 
26005  CylinderKey & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
26006 
26012  CylinderKey & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
26013 
26016  CylinderKey & UnsetVertexColors();
26017 
26022  CylinderKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
26023 
26027  CylinderKey & UnsetVertexColors(Cylinder::Component in_apply_to);
26028 
26034  CylinderKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Cylinder::Component in_apply_to);
26035 
26040  CylinderKey & UnsetVertexColorsByList(size_t in_count, size_t const in_vertices[]);
26041 
26045  CylinderKey & UnsetVertexColorsByList(SizeTArray const & in_vertices);
26046 
26052  CylinderKey & UnsetVertexColorsByList(size_t in_count, size_t const in_vertices[], Cylinder::Component in_apply_to);
26053 
26059  CylinderKey & UnsetVertexColorsByList(SizeTArray const & in_vertices, Cylinder::Component in_apply_to);
26060 
26070  bool ShowVertexColors(Cylinder::Component in_apply_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
26071 
26083  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;
26084 
26097  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Cylinder::Component in_apply_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
26098 };
26099 
26100 
26101 
26102 
26104 class HPS_API SphereKit : public Kit
26105 {
26106 public:
26108  SphereKit();
26109 
26112  SphereKit(SphereKit const & in_kit);
26113 
26117  SphereKit(SphereKit && in_that);
26118 
26122  SphereKit & operator=(SphereKit && in_that);
26123 
26124  virtual ~SphereKit();
26125 
26126  static const HPS::Type staticType = HPS::Type::SphereKit;
26127  HPS::Type ObjectType() const { return staticType; };
26128 
26131  void Consume(SphereKit & in_kit);
26132 
26135  void Set(SphereKit const & in_kit);
26136 
26139  void Show(SphereKit & out_kit) const;
26140 
26144  SphereKit & operator=(SphereKit const & in_kit);
26145 
26148  bool Empty() const;
26149 
26153  bool Equals(SphereKit const & in_kit) const;
26154 
26158  bool operator==(SphereKit const & in_kit) const;
26159 
26163  bool operator!=(SphereKit const & in_kit) const;
26164 
26171  SphereKit & SetPriority(int in_priority);
26172 
26175  SphereKit & UnsetPriority();
26176 
26180  bool ShowPriority(int & out_priority) const;
26181 
26185  SphereKit & SetCenter(Point const & in_center);
26186 
26190  SphereKit & SetRadius(float in_radius);
26191 
26196  SphereKit & SetBasis(Vector const & in_vertical, Vector const & in_horizontal);
26197 
26198 
26201  SphereKit & UnsetCenter();
26202 
26205  SphereKit & UnsetRadius();
26206 
26209  SphereKit & UnsetBasis();
26210 
26213  SphereKit & UnsetEverything();
26214 
26215 
26219  bool ShowCenter(Point & out_center) const;
26220 
26224  bool ShowRadius(float & out_radius) const;
26225 
26230  bool ShowBasis(Vector & out_vertical, Vector & out_horizontal) const;
26231 
26237  SphereKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
26238 
26243  SphereKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
26244 
26249  SphereKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
26250 
26254  SphereKit & UnsetUserData(intptr_t in_index);
26255 
26260  SphereKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
26261 
26265  SphereKit & UnsetUserData(IntPtrTArray const & in_indices);
26266 
26269  SphereKit & UnsetAllUserData();
26270 
26272  size_t ShowUserDataCount() const;
26273 
26277  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
26278 
26283  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
26284 
26289  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
26290 };
26291 
26293 class HPS_API SphereKey : public GeometryKey
26294 {
26295 public:
26297  SphereKey();
26298 
26302  explicit SphereKey(Key const & in_that);
26303 
26306  SphereKey(SphereKey const & in_that);
26307 
26311  SphereKey & operator=(SphereKey const & in_that);
26312 
26316  SphereKey(SphereKey && in_that);
26317 
26321  SphereKey & operator=(SphereKey && in_that);
26322 
26323  ~SphereKey();
26324 
26325  static const HPS::Type staticType = HPS::Type::SphereKey;
26326  HPS::Type ObjectType() const {return staticType;};
26327 
26330  void Consume(SphereKit & in_kit);
26331 
26334  void Set(SphereKit const & in_kit);
26335 
26338  void Show(SphereKit & out_kit) const;
26339 
26340 
26344  SphereKey & SetCenter(Point const & in_center);
26345 
26349  SphereKey & SetRadius(float in_radius);
26350 
26355  SphereKey & SetBasis(Vector const & in_vertical, Vector const & in_horizontal);
26356 
26357 
26361  bool ShowCenter(Point & out_center) const;
26362 
26366  bool ShowRadius(float & out_radius) const;
26367 
26372  bool ShowBasis(Vector & out_vertical, Vector & out_horizontal) const;
26373 };
26374 
26375 
26376 
26377 
26379 class HPS_API CircleKit : public Kit
26380 {
26381 public:
26383  CircleKit();
26384 
26387  CircleKit(CircleKit const & in_kit);
26388 
26392  CircleKit(CircleKit && in_that);
26393 
26397  CircleKit & operator=(CircleKit && in_that);
26398 
26399  virtual ~CircleKit();
26400 
26401  static const HPS::Type staticType = HPS::Type::CircleKit;
26402  HPS::Type ObjectType() const { return staticType; };
26403 
26406  void Consume(CircleKit & in_kit);
26407 
26410  void Set(CircleKit const & in_kit);
26411 
26414  void Show(CircleKit & out_kit) const;
26415 
26419  CircleKit & operator=(CircleKit const & in_kit);
26420 
26423  bool Empty() const;
26424 
26428  bool Equals(CircleKit const & in_kit) const;
26429 
26433  bool operator==(CircleKit const & in_kit) const;
26434 
26438  bool operator!=(CircleKit const & in_kit) const;
26439 
26446  CircleKit & SetPriority(int const in_priority);
26447 
26450  CircleKit & UnsetPriority();
26451 
26455  bool ShowPriority(int & out_priority) const;
26456 
26457 
26458 
26462  CircleKit & SetCenter(Point const & in_center);
26463 
26467  CircleKit & SetRadius(float in_radius);
26468 
26472  CircleKit & SetNormal(Vector const & in_normal);
26473 
26474 
26477  CircleKit & UnsetCenter();
26478 
26481  CircleKit & UnsetRadius();
26482 
26485  CircleKit & UnsetNormal();
26486 
26489  CircleKit & UnsetEverything();
26490 
26491 
26495  bool ShowCenter(Point & out_center) const;
26496 
26500  bool ShowRadius(float & out_radius) const;
26501 
26505  bool ShowNormal(Vector & out_normal) const;
26506 
26512  CircleKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
26513 
26518  CircleKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
26519 
26524  CircleKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
26525 
26529  CircleKit & UnsetUserData(intptr_t in_index);
26530 
26535  CircleKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
26536 
26540  CircleKit & UnsetUserData(IntPtrTArray const & in_indices);
26541 
26544  CircleKit & UnsetAllUserData();
26545 
26547  size_t ShowUserDataCount() const;
26548 
26552  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
26553 
26558  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
26559 
26564  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
26565 };
26566 
26567 
26570 class HPS_API CircleKey : public GeometryKey
26571 {
26572 public:
26574  CircleKey();
26575 
26579  explicit CircleKey(Key const & in_that);
26580 
26583  CircleKey(CircleKey const & in_that);
26584 
26588  CircleKey & operator=(CircleKey const & in_that);
26589 
26593  CircleKey(CircleKey && in_that);
26594 
26598  CircleKey & operator=(CircleKey && in_that);
26599 
26600  ~CircleKey();
26601 
26602  static const HPS::Type staticType = HPS::Type::CircleKey;
26603  HPS::Type ObjectType() const { return staticType; };
26604 
26605 
26608  void Consume(CircleKit & in_kit);
26609 
26612  void Set(CircleKit const & in_kit);
26613 
26616  void Show(CircleKit & out_kit) const;
26617 
26618 
26622  CircleKey & SetCenter(Point const & in_center);
26623 
26627  CircleKey & SetRadius(float in_radius);
26628 
26632  CircleKey & SetNormal(Vector const & in_normal);
26633 
26634 
26638  bool ShowCenter(Point & out_center) const;
26639 
26643  bool ShowRadius(float & out_radius) const;
26644 
26648  bool ShowNormal(Vector & out_normal) const;
26649 };
26650 
26651 
26652 
26653 
26655 class HPS_API CircularArcKit : public Kit
26656 {
26657 public:
26659  CircularArcKit();
26660 
26663  CircularArcKit(CircularArcKit const & in_kit);
26664 
26668  CircularArcKit(CircularArcKit && in_that);
26669 
26673  CircularArcKit & operator=(CircularArcKit && in_that);
26674 
26675  virtual ~CircularArcKit();
26676 
26677  static const HPS::Type staticType = HPS::Type::CircularArcKit;
26678  HPS::Type ObjectType() const { return staticType; };
26679 
26682  void Consume(CircularArcKit & in_kit);
26683 
26686  void Set(CircularArcKit const & in_kit);
26687 
26690  void Show(CircularArcKit & out_kit) const;
26691 
26695  CircularArcKit & operator=(CircularArcKit const & in_kit);
26696 
26699  bool Empty() const;
26700 
26704  bool Equals(CircularArcKit const & in_kit) const;
26705 
26709  bool operator==(CircularArcKit const & in_kit) const;
26710 
26714  bool operator!=(CircularArcKit const & in_kit) const;
26715 
26722  CircularArcKit & SetPriority(int in_priority);
26723 
26726  CircularArcKit & UnsetPriority();
26727 
26731  bool ShowPriority(int & out_priority) const;
26732 
26733 
26737  CircularArcKit & SetStart(Point const & in_start);
26738 
26742  CircularArcKit & SetMiddle(Point const & in_middle);
26743 
26747  CircularArcKit & SetEnd(Point const & in_end);
26748 
26749 
26752  CircularArcKit & UnsetStart();
26753 
26756  CircularArcKit & UnsetMiddle();
26757 
26760  CircularArcKit & UnsetEnd();
26761 
26764  CircularArcKit & UnsetEverything();
26765 
26766 
26770  bool ShowStart(Point & out_start) const;
26771 
26775  bool ShowMiddle(Point & out_middle) const;
26776 
26780  bool ShowEnd(Point & out_end) const;
26781 
26787  CircularArcKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
26788 
26793  CircularArcKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
26794 
26799  CircularArcKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
26800 
26804  CircularArcKit & UnsetUserData(intptr_t in_index);
26805 
26810  CircularArcKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
26811 
26815  CircularArcKit & UnsetUserData(IntPtrTArray const & in_indices);
26816 
26819  CircularArcKit & UnsetAllUserData();
26820 
26822  size_t ShowUserDataCount() const;
26823 
26827  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
26828 
26833  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
26834 
26839  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
26840 };
26841 
26844 class HPS_API CircularArcKey : public GeometryKey
26845 {
26846 public:
26848  CircularArcKey();
26849 
26853  explicit CircularArcKey(Key const & in_that);
26854 
26857  CircularArcKey(CircularArcKey const & in_that);
26858 
26862  CircularArcKey & operator=(CircularArcKey const & in_that);
26863 
26867  CircularArcKey(CircularArcKey && in_that);
26868 
26872  CircularArcKey & operator=(CircularArcKey && in_that);
26873 
26874  ~CircularArcKey();
26875 
26876  static const HPS::Type staticType = HPS::Type::CircularArcKey;
26877  HPS::Type ObjectType() const { return staticType; };
26878 
26879 
26882  void Consume(CircularArcKit & in_kit);
26883 
26886  void Set(CircularArcKit const & in_kit);
26887 
26890  void Show(CircularArcKit & out_kit) const;
26891 
26892 
26896  CircularArcKey & SetStart(Point const & in_start);
26897 
26901  CircularArcKey & SetMiddle(Point const & in_middle);
26902 
26906  CircularArcKey & SetEnd(Point const & in_end);
26907 
26908 
26912  bool ShowStart(Point & out_start) const;
26913 
26917  bool ShowMiddle(Point & out_middle) const;
26918 
26922  bool ShowEnd(Point & out_end) const;
26923 };
26924 
26925 
26926 
26928 class HPS_API CircularWedgeKit : public Kit
26929 {
26930 public:
26932  CircularWedgeKit();
26933 
26936  CircularWedgeKit(CircularWedgeKit const & in_kit);
26937 
26941  CircularWedgeKit(CircularWedgeKit && in_that);
26942 
26946  CircularWedgeKit & operator=(CircularWedgeKit && in_that);
26947 
26948  virtual ~CircularWedgeKit();
26949 
26950  static const HPS::Type staticType = HPS::Type::CircularWedgeKit;
26951  HPS::Type ObjectType() const { return staticType; };
26952 
26955  void Consume(CircularWedgeKit & in_kit);
26956 
26959  void Set(CircularWedgeKit const & in_kit);
26960 
26963  void Show(CircularWedgeKit & out_kit) const;
26964 
26968  CircularWedgeKit & operator=(CircularWedgeKit const & in_kit);
26969 
26972  bool Empty() const;
26973 
26977  bool Equals(CircularWedgeKit const & in_kit) const;
26978 
26982  bool operator==(CircularWedgeKit const & in_kit) const;
26983 
26987  bool operator!=(CircularWedgeKit const & in_kit) const;
26988 
26989 
26996  CircularWedgeKit & SetPriority(int in_priority);
26997 
27000  CircularWedgeKit & UnsetPriority();
27001 
27005  bool ShowPriority(int & out_priority) const;
27006 
27007 
27011  CircularWedgeKit & SetStart(Point const & in_start);
27012 
27016  CircularWedgeKit & SetMiddle(Point const & in_middle);
27017 
27021  CircularWedgeKit & SetEnd(Point const & in_end);
27022 
27023 
27026  CircularWedgeKit & UnsetStart();
27027 
27030  CircularWedgeKit & UnsetMiddle();
27031 
27034  CircularWedgeKit & UnsetEnd();
27035 
27038  CircularWedgeKit & UnsetEverything();
27039 
27040 
27044  bool ShowStart(Point & out_start) const;
27045 
27049  bool ShowMiddle(Point & out_middle) const;
27050 
27054  bool ShowEnd(Point & out_end) const;
27055 
27061  CircularWedgeKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
27062 
27067  CircularWedgeKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
27068 
27073  CircularWedgeKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
27074 
27078  CircularWedgeKit & UnsetUserData(intptr_t in_index);
27079 
27084  CircularWedgeKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
27085 
27089  CircularWedgeKit & UnsetUserData(IntPtrTArray const & in_indices);
27090 
27093  CircularWedgeKit & UnsetAllUserData();
27094 
27096  size_t ShowUserDataCount() const;
27097 
27101  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
27102 
27107  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
27108 
27113  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
27114 };
27115 
27116 
27120 class HPS_API CircularWedgeKey : public GeometryKey
27121 {
27122 public:
27124  CircularWedgeKey();
27125 
27129  explicit CircularWedgeKey(Key const & in_that);
27130 
27133  CircularWedgeKey(CircularWedgeKey const & in_that);
27134 
27138  CircularWedgeKey & operator=(CircularWedgeKey const & in_that);
27139 
27143  CircularWedgeKey(CircularWedgeKey && in_that);
27144 
27148  CircularWedgeKey & operator=(CircularWedgeKey && in_that);
27149 
27150  ~CircularWedgeKey();
27151 
27152  static const HPS::Type staticType = HPS::Type::CircularWedgeKey;
27153  HPS::Type ObjectType() const { return staticType; };
27154 
27155 
27158  void Consume(CircularWedgeKit & in_kit);
27159 
27162  void Set(CircularWedgeKit const & in_kit);
27163 
27166  void Show(CircularWedgeKit & out_kit) const;
27167 
27168 
27172  CircularWedgeKey & SetStart(Point const & in_start);
27173 
27177  CircularWedgeKey & SetMiddle(Point const & in_middle);
27178 
27182  CircularWedgeKey & SetEnd(Point const & in_end);
27183 
27184 
27188  bool ShowStart(Point & out_start) const;
27189 
27193  bool ShowMiddle(Point & out_middle) const;
27194 
27198  bool ShowEnd(Point & out_end) const;
27199 };
27200 
27201 
27202 
27204 class HPS_API CuttingSectionKit : public Kit
27205 {
27206 public:
27209 
27212  CuttingSectionKit(CuttingSectionKit const & in_kit);
27213 
27218 
27222  CuttingSectionKit & operator=(CuttingSectionKit && in_that);
27223 
27224  virtual ~CuttingSectionKit();
27225 
27226  static const HPS::Type staticType = HPS::Type::CuttingSectionKit;
27227  HPS::Type ObjectType() const { return staticType; };
27228 
27231  void Consume(CuttingSectionKit & in_kit);
27232 
27235  void Set(CuttingSectionKit const & in_kit);
27236 
27239  void Show(CuttingSectionKit & out_kit) const;
27240 
27244  CuttingSectionKit & operator=(CuttingSectionKit const & in_kit);
27245 
27248  bool Empty() const;
27249 
27253  bool Equals(CuttingSectionKit const & in_kit) const;
27254 
27258  bool operator==(CuttingSectionKit const & in_kit) const;
27259 
27263  bool operator!=(CuttingSectionKit const & in_kit) const;
27264 
27271  CuttingSectionKit & SetPriority(int in_priority);
27272 
27275  CuttingSectionKit & UnsetPriority();
27276 
27280  bool ShowPriority(int & out_priority) const;
27281 
27282 
27286  CuttingSectionKit & SetPlanes(Plane const & in_plane);
27287 
27291  CuttingSectionKit & SetPlanes(PlaneArray const & in_planes);
27292 
27297  CuttingSectionKit & SetPlanes(size_t in_count, Plane const in_planes[]);
27298 
27304  CuttingSectionKit & SetVisualization(CuttingSection::Mode in_mode, RGBAColor const & in_color, float in_scale = 1.0f);
27305 
27306 
27309  CuttingSectionKit & UnsetPlanes();
27310 
27313  CuttingSectionKit & UnsetVisualization();
27314 
27317  CuttingSectionKit & UnsetEverything();
27318 
27319 
27322  size_t GetPlaneCount() const;
27323 
27327  bool ShowPlanes(HPS::PlaneArray & out_planes) const;
27328 
27334  bool ShowVisualization(CuttingSection::Mode & out_mode, RGBAColor & out_color, float & out_scale) const;
27335 
27336 
27343  CuttingSectionKit & EditPlanesByInsertion(size_t in_offset, size_t in_count, Plane const in_planes[]);
27344 
27350  CuttingSectionKit & EditPlanesByInsertion(size_t in_offset, PlaneArray const & in_planes);
27351 
27358  CuttingSectionKit & EditPlanesByDeletion(size_t in_offset, size_t in_count);
27359 
27366  CuttingSectionKit & EditPlanesByReplacement(size_t in_offset, size_t in_count, Plane const in_planes[]);
27367 
27375  CuttingSectionKit & EditPlanesByReplacement(size_t in_offset, PlaneArray const & in_planes);
27376 
27382  CuttingSectionKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
27383 
27388  CuttingSectionKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
27389 
27394  CuttingSectionKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
27395 
27399  CuttingSectionKit & UnsetUserData(intptr_t in_index);
27400 
27405  CuttingSectionKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
27406 
27410  CuttingSectionKit & UnsetUserData(IntPtrTArray const & in_indices);
27411 
27414  CuttingSectionKit & UnsetAllUserData();
27415 
27417  size_t ShowUserDataCount() const;
27418 
27422  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
27423 
27428  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
27429 
27434  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
27435 };
27436 
27437 
27439 class HPS_API CuttingSectionKey : public GeometryKey
27440 {
27441 public:
27444 
27448  explicit CuttingSectionKey(Key const & in_that);
27449 
27452  CuttingSectionKey(CuttingSectionKey const & in_that);
27453 
27457  CuttingSectionKey & operator=(CuttingSectionKey const & in_that);
27458 
27463 
27467  CuttingSectionKey & operator=(CuttingSectionKey && in_that);
27468 
27469  ~CuttingSectionKey();
27470 
27471  static const HPS::Type staticType = HPS::Type::CuttingSectionKey;
27472  HPS::Type ObjectType() const { return staticType; };
27473 
27474 
27477  void Consume(CuttingSectionKit & in_kit);
27478 
27481  void Set(CuttingSectionKit const & in_kit);
27482 
27485  void Show(CuttingSectionKit & out_kit) const;
27486 
27487 
27491  CuttingSectionKey & SetPlanes(Plane const & in_plane);
27492 
27496  CuttingSectionKey & SetPlanes(PlaneArray const & in_planes);
27497 
27502  CuttingSectionKey & SetPlanes(size_t in_count, Plane const in_planes[]);
27503 
27509  CuttingSectionKey & SetVisualization(CuttingSection::Mode in_mode, RGBAColor const & in_color, float in_scale = 1.0f);
27510 
27511 
27514  size_t GetPlaneCount() const;
27515 
27519  bool ShowPlanes(HPS::PlaneArray & out_planes) const;
27520 
27526  bool ShowVisualization(CuttingSection::Mode & out_mode, RGBAColor & out_color, float & out_scale) const;
27527 
27528 
27535  CuttingSectionKey & EditPlanesByInsertion(size_t in_offset, size_t in_count, Plane const in_planes[]);
27536 
27542  CuttingSectionKey & EditPlanesByInsertion(size_t in_offset, PlaneArray const & in_planes);
27543 
27550  CuttingSectionKey & EditPlanesByDeletion(size_t in_offset, size_t in_count);
27551 
27558  CuttingSectionKey & EditPlanesByReplacement(size_t in_offset, size_t in_count, Plane const in_planes[]);
27559 
27565  CuttingSectionKey & EditPlanesByReplacement(size_t in_offset, PlaneArray const & in_planes);
27566 };
27567 
27568 
27569 
27571 class HPS_API InfiniteLineKit : public Kit
27572 {
27573 public:
27575  InfiniteLineKit();
27576 
27579  InfiniteLineKit(InfiniteLineKit const & in_kit);
27580 
27584  InfiniteLineKit(InfiniteLineKit && in_that);
27585 
27589  InfiniteLineKit & operator=(InfiniteLineKit && in_that);
27590 
27591  virtual ~InfiniteLineKit();
27592 
27593  static const HPS::Type staticType = HPS::Type::InfiniteLineKit;
27594  HPS::Type ObjectType() const { return staticType; };
27595 
27598  void Consume(InfiniteLineKit & in_kit);
27599 
27602  void Set(InfiniteLineKit const & in_kit);
27603 
27606  void Show(InfiniteLineKit & out_kit) const;
27607 
27611  InfiniteLineKit & operator=(InfiniteLineKit const & in_kit);
27612 
27615  bool Empty() const;
27616 
27620  bool Equals(InfiniteLineKit const & in_kit) const;
27621 
27625  bool operator==(InfiniteLineKit const & in_kit) const;
27626 
27630  bool operator!=(InfiniteLineKit const & in_kit) const;
27631 
27638  InfiniteLineKit & SetPriority(int in_priority);
27639 
27642  InfiniteLineKit & UnsetPriority();
27643 
27647  bool ShowPriority(int & out_priority) const;
27648 
27649 
27653  InfiniteLineKit & SetFirst(Point const & in_first);
27654 
27658  InfiniteLineKit & SetSecond(Point const & in_second);
27659 
27663  InfiniteLineKit & SetType(InfiniteLine::Type in_type);
27664 
27665 
27668  InfiniteLineKit & UnsetFirst();
27669 
27672  InfiniteLineKit & UnsetSecond();
27673 
27676  InfiniteLineKit & UnsetType();
27677 
27680  InfiniteLineKit & UnsetEverything();
27681 
27682 
27686  bool ShowFirst(Point & out_first) const;
27687 
27691  bool ShowSecond(Point & out_second) const;
27692 
27696  bool ShowType(InfiniteLine::Type & out_type) const;
27697 
27703  InfiniteLineKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
27704 
27709  InfiniteLineKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
27710 
27715  InfiniteLineKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
27716 
27720  InfiniteLineKit & UnsetUserData(intptr_t in_index);
27721 
27726  InfiniteLineKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
27727 
27731  InfiniteLineKit & UnsetUserData(IntPtrTArray const & in_indices);
27732 
27735  InfiniteLineKit & UnsetAllUserData();
27736 
27738  size_t ShowUserDataCount() const;
27739 
27743  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
27744 
27749  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
27750 
27755  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
27756 };
27757 
27758 
27760 class HPS_API InfiniteLineKey : public GeometryKey
27761 {
27762 public:
27764  InfiniteLineKey();
27765 
27769  explicit InfiniteLineKey(Key const & in_that);
27770 
27773  InfiniteLineKey(InfiniteLineKey const & in_that);
27774 
27778  InfiniteLineKey & operator=(InfiniteLineKey const & in_that);
27779 
27783  InfiniteLineKey(InfiniteLineKey && in_that);
27784 
27788  InfiniteLineKey & operator=(InfiniteLineKey && in_that);
27789 
27790  ~InfiniteLineKey();
27791 
27792  static const HPS::Type staticType = HPS::Type::InfiniteLineKey;
27793  HPS::Type ObjectType() const { return staticType; };
27794 
27797  void Consume(InfiniteLineKit & in_kit);
27798 
27801  void Set(InfiniteLineKit const & in_kit);
27802 
27805  void Show(InfiniteLineKit & out_kit) const;
27806 
27807 
27811  InfiniteLineKey & SetFirst(Point const & in_first);
27812 
27816  InfiniteLineKey & SetSecond(Point const & in_second);
27817 
27821  InfiniteLineKey & SetType(InfiniteLine::Type in_type);
27822 
27823 
27827  bool ShowFirst(Point & out_first) const;
27828 
27832  bool ShowSecond(Point & out_second) const;
27833 
27837  bool ShowType(InfiniteLine::Type & out_type) const;
27838 };
27839 
27840 
27841 
27845 class HPS_API SpotlightKit : public Kit
27846 {
27847 public:
27849  SpotlightKit();
27850 
27853  SpotlightKit(SpotlightKit const & in_kit);
27854 
27858  SpotlightKit(SpotlightKit && in_that);
27859 
27863  SpotlightKit & operator=(SpotlightKit && in_that);
27864 
27865  virtual ~SpotlightKit();
27866 
27867  static const HPS::Type staticType = HPS::Type::SpotlightKit;
27868  HPS::Type ObjectType() const { return staticType; };
27869 
27873  static SpotlightKit GetDefault();
27874 
27877  void Consume(SpotlightKit & in_kit);
27878 
27881  void Set(SpotlightKit const & in_kit);
27882 
27885  void Show(SpotlightKit & out_kit) const;
27886 
27890  SpotlightKit & operator=(SpotlightKit const & in_kit);
27891 
27894  bool Empty() const;
27895 
27899  bool Equals(SpotlightKit const & in_kit) const;
27900 
27904  bool operator==(SpotlightKit const & in_kit) const;
27905 
27909  bool operator!=(SpotlightKit const & in_kit) const;
27910 
27911 
27918  SpotlightKit & SetPriority(int in_priority);
27919 
27925  SpotlightKit & SetPosition(HPS::Point const & in_position);
27926 
27932  SpotlightKit & SetTarget(HPS::Point const & in_target);
27933 
27937  SpotlightKit & SetColor(RGBAColor const & in_rgba_color);
27938 
27942  SpotlightKit & SetColorByIndex(float in_index);
27943 
27950 
27957 
27963  SpotlightKit & SetConcentration(float in_concentration);
27964 
27970  SpotlightKit & SetCameraRelative(bool in_state);
27971 
27972 
27975  SpotlightKit & UnsetPriority();
27976 
27979  SpotlightKit & UnsetPosition();
27980 
27983  SpotlightKit & UnsetTarget();
27984 
27987  SpotlightKit & UnsetColor();
27988 
27991  SpotlightKit & UnsetOuterCone();
27992 
27995  SpotlightKit & UnsetInnerCone();
27996 
27999  SpotlightKit & UnsetConcentration();
28000 
28003  SpotlightKit & UnsetCameraRelative();
28004 
28007  SpotlightKit & UnsetEverything();
28008 
28009 
28013  bool ShowPriority(int & out_priority) const;
28014 
28018  bool ShowPosition(HPS::Point & out_position) const;
28019 
28023  bool ShowTarget(HPS::Point & out_target) const;
28024 
28030  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
28031 
28036  bool ShowOuterCone(float & out_size, HPS::Spotlight::OuterConeUnits & out_units) const;
28037 
28042  bool ShowInnerCone(float & out_size, HPS::Spotlight::InnerConeUnits & out_units) const;
28043 
28047  bool ShowConcentration(float & out_concentration) const;
28048 
28052  bool ShowCameraRelative(bool & out_state) const;
28053 
28059  SpotlightKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
28060 
28065  SpotlightKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
28066 
28071  SpotlightKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
28072 
28076  SpotlightKit & UnsetUserData(intptr_t in_index);
28077 
28082  SpotlightKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
28083 
28087  SpotlightKit & UnsetUserData(IntPtrTArray const & in_indices);
28088 
28091  SpotlightKit & UnsetAllUserData();
28092 
28094  size_t ShowUserDataCount() const;
28095 
28099  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
28100 
28105  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
28106 
28111  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
28112 };
28113 
28114 
28116 class HPS_API SpotlightKey : public GeometryKey
28117 {
28118 public:
28120  SpotlightKey();
28121 
28125  explicit SpotlightKey(Key const & in_that);
28126 
28129  SpotlightKey(SpotlightKey const & in_that);
28130 
28134  SpotlightKey & operator=(SpotlightKey const & in_that);
28135 
28139  SpotlightKey(SpotlightKey && in_that);
28140 
28144  SpotlightKey & operator=(SpotlightKey && in_that);
28145 
28146  ~SpotlightKey();
28147 
28148  static const HPS::Type staticType = HPS::Type::SpotlightKey;
28149  HPS::Type ObjectType() const { return staticType; };
28150 
28153  void Consume(SpotlightKit & in_kit);
28154 
28157  void Set(SpotlightKit const & in_kit);
28158 
28161  void Show(SpotlightKit & out_kit) const;
28162 
28163 
28169  SpotlightKey & SetPosition(HPS::Point const & in_position);
28170 
28176  SpotlightKey & SetTarget(HPS::Point const & in_target);
28177 
28181  SpotlightKey & SetColor(RGBAColor const & in_rgba_color);
28182 
28186  SpotlightKey & SetColorByIndex(float in_index);
28187 
28194 
28201 
28207  SpotlightKey & SetConcentration(float in_concentration);
28208 
28214  SpotlightKey & SetCameraRelative(bool in_state);
28215 
28216 
28219  SpotlightKey & UnsetColor();
28220 
28221 
28225  bool ShowPosition(HPS::Point & out_position) const;
28226 
28230  bool ShowTarget(HPS::Point & out_target) const;
28231 
28237  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
28238 
28243  bool ShowOuterCone(float & out_size, HPS::Spotlight::OuterConeUnits & out_units) const;
28244 
28249  bool ShowInnerCone(float & out_size, HPS::Spotlight::InnerConeUnits & out_units) const;
28250 
28254  bool ShowConcentration(float & out_concentration) const;
28255 
28259  bool ShowCameraRelative(bool & out_state) const;
28260 };
28261 
28262 
28263 
28265 class HPS_API NURBSCurveKit : public Kit
28266 {
28267 public:
28269  NURBSCurveKit();
28270 
28273  NURBSCurveKit(NURBSCurveKit const & in_kit);
28274 
28278  NURBSCurveKit(NURBSCurveKit && in_that);
28279 
28283  NURBSCurveKit & operator=(NURBSCurveKit && in_that);
28284 
28285  virtual ~NURBSCurveKit();
28286 
28287  static const HPS::Type staticType = HPS::Type::NURBSCurveKit;
28288  HPS::Type ObjectType() const { return staticType; };
28289 
28292  void Consume(NURBSCurveKit & in_kit);
28293 
28296  void Set(NURBSCurveKit const & in_kit);
28297 
28300  void Show(NURBSCurveKit & out_kit) const;
28301 
28305  NURBSCurveKit & operator=(NURBSCurveKit const & in_kit);
28306 
28309  bool Empty() const;
28310 
28314  bool Equals(NURBSCurveKit const & in_kit) const;
28315 
28319  bool operator==(NURBSCurveKit const & in_kit) const;
28320 
28324  bool operator!=(NURBSCurveKit const & in_kit) const;
28325 
28328  size_t GetPointCount() const;
28329 
28336  NURBSCurveKit & SetPriority(int in_priority);
28337 
28340  NURBSCurveKit & UnsetPriority();
28341 
28345  bool ShowPriority(int & out_priority) const;
28346 
28350  NURBSCurveKit & SetDegree(size_t in_degree);
28351 
28355  NURBSCurveKit & SetPoints(PointArray const & in_points);
28356 
28361  NURBSCurveKit & SetPoints(size_t in_count, Point const in_points []);
28362 
28366  NURBSCurveKit & SetWeights(FloatArray const & in_weights);
28367 
28372  NURBSCurveKit & SetWeights(size_t in_count, float const in_weights []);
28373 
28377  NURBSCurveKit & SetKnots(FloatArray const & in_knots);
28378 
28383  NURBSCurveKit & SetKnots(size_t in_count, float const in_knots []);
28384 
28389  NURBSCurveKit & SetParameters(float in_start, float in_end);
28390 
28391 
28394  NURBSCurveKit & UnsetDegree();
28395 
28398  NURBSCurveKit & UnsetPoints();
28399 
28402  NURBSCurveKit & UnsetWeights();
28403 
28406  NURBSCurveKit & UnsetKnots();
28407 
28410  NURBSCurveKit & UnsetParameters();
28411 
28414  NURBSCurveKit & UnsetEverything();
28415 
28416 
28420  bool ShowDegree(size_t & out_degree) const;
28421 
28425  bool ShowPoints(PointArray & out_points) const;
28426 
28432  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
28433 
28438  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
28439 
28445  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
28446 
28450  bool ShowWeights(FloatArray & out_weights) const;
28451 
28455  bool ShowKnots(FloatArray & out_knots) const;
28456 
28461  bool ShowParameters(float & out_start, float & out_end) const;
28462 
28463 
28470  NURBSCurveKit & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
28471 
28477  NURBSCurveKit & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
28478 
28485  NURBSCurveKit & EditPointsByDeletion(size_t in_offset, size_t in_count);
28486 
28493  NURBSCurveKit & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
28494 
28501  NURBSCurveKit & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
28502 
28503 
28511  NURBSCurveKit & EditWeightsByInsertion(size_t in_offset, size_t in_count, float const in_weights[]);
28512 
28519  NURBSCurveKit & EditWeightsByInsertion(size_t in_offset, FloatArray const & in_weights);
28520 
28528  NURBSCurveKit & EditWeightsByDeletion(size_t in_offset, size_t in_count);
28529 
28536  NURBSCurveKit & EditWeightsByReplacement(size_t in_offset, size_t in_count, float const in_weights[]);
28537 
28544  NURBSCurveKit & EditWeightsByReplacement(size_t in_offset, FloatArray const & in_weights);
28545 
28546 
28552  NURBSCurveKit & EditKnotsByInsertion(size_t in_offset, size_t in_count, float const in_knots[]);
28553 
28558  NURBSCurveKit & EditKnotsByInsertion(size_t in_offset, FloatArray const & in_knots);
28559 
28565  NURBSCurveKit & EditKnotsByDeletion(size_t in_offset, size_t in_count);
28566 
28573  NURBSCurveKit & EditKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
28574 
28581  NURBSCurveKit & EditKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
28582 
28588  NURBSCurveKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
28589 
28594  NURBSCurveKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
28595 
28600  NURBSCurveKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
28601 
28605  NURBSCurveKit & UnsetUserData(intptr_t in_index);
28606 
28611  NURBSCurveKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
28612 
28616  NURBSCurveKit & UnsetUserData(IntPtrTArray const & in_indices);
28617 
28620  NURBSCurveKit & UnsetAllUserData();
28621 
28623  size_t ShowUserDataCount() const;
28624 
28628  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
28629 
28634  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
28635 
28640  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
28641 };
28642 
28643 
28645 class HPS_API NURBSCurveKey : public GeometryKey
28646 {
28647 public:
28649  NURBSCurveKey();
28650 
28654  explicit NURBSCurveKey(Key const & in_that);
28655 
28658  NURBSCurveKey(NURBSCurveKey const & in_that);
28659 
28663  NURBSCurveKey & operator=(NURBSCurveKey const & in_that);
28664 
28668  NURBSCurveKey(NURBSCurveKey && in_that);
28669 
28673  NURBSCurveKey & operator=(NURBSCurveKey && in_that);
28674 
28675  ~NURBSCurveKey();
28676 
28677  static const HPS::Type staticType = HPS::Type::NURBSCurveKey;
28678  HPS::Type ObjectType() const {return staticType;};
28679 
28682  void Consume(NURBSCurveKit & in_kit);
28683 
28686  void Set(NURBSCurveKit const & in_kit);
28687 
28690  void Show(NURBSCurveKit & out_kit) const;
28691 
28694  size_t GetPointCount() const;
28695 
28700  NURBSCurveKey & SetParameters(float in_start, float in_end);
28701 
28705  bool ShowDegree(size_t & out_degree) const;
28706 
28710  bool ShowPoints(PointArray & out_points) const;
28711 
28717  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
28718 
28723  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
28724 
28730  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
28731 
28735  bool ShowWeights(FloatArray & out_weights) const;
28736 
28740  bool ShowKnots(FloatArray & out_knots) const;
28741 
28746  bool ShowParameters(float & out_start, float & out_end) const;
28747 
28748 
28756  NURBSCurveKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
28757 
28764  NURBSCurveKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
28765 
28766 
28775  NURBSCurveKey & EditWeightsByReplacement(size_t in_offset, size_t in_count, float const in_weights[]);
28776 
28784  NURBSCurveKey & EditWeightsByReplacement(size_t in_offset, FloatArray const & in_weights);
28785 
28786 
28794  NURBSCurveKey & EditKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
28795 
28802  NURBSCurveKey & EditKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
28803 };
28804 
28805 
28806 
28808 class HPS_API NURBSSurfaceKit : public Kit
28809 {
28810 public:
28812  NURBSSurfaceKit();
28813 
28816  NURBSSurfaceKit(NURBSSurfaceKit const & in_kit);
28817 
28821  NURBSSurfaceKit(NURBSSurfaceKit && in_that);
28822 
28826  NURBSSurfaceKit & operator=(NURBSSurfaceKit && in_that);
28827 
28828  virtual ~NURBSSurfaceKit();
28829 
28830  static const HPS::Type staticType = HPS::Type::NURBSSurfaceKit;
28831  HPS::Type ObjectType() const { return staticType; };
28832 
28835  void Consume(NURBSSurfaceKit & in_kit);
28836 
28839  void Set(NURBSSurfaceKit const & in_kit);
28840 
28843  void Show(NURBSSurfaceKit & out_kit) const;
28844 
28848  NURBSSurfaceKit & operator=(NURBSSurfaceKit const & in_kit);
28849 
28852  bool Empty() const;
28853 
28857  bool Equals(NURBSSurfaceKit const & in_kit) const;
28858 
28862  bool operator==(NURBSSurfaceKit const & in_kit) const;
28863 
28867  bool operator!=(NURBSSurfaceKit const & in_kit) const;
28868 
28871  size_t GetPointCount() const;
28872 
28879  NURBSSurfaceKit & SetPriority(int in_priority);
28880 
28883  NURBSSurfaceKit & UnsetPriority();
28884 
28888  bool ShowPriority(int & out_priority) const;
28889 
28893  NURBSSurfaceKit & SetUDegree(size_t in_degree);
28894 
28898  NURBSSurfaceKit & SetVDegree(size_t in_degree);
28899 
28903  NURBSSurfaceKit & SetUCount(size_t in_count);
28904 
28908  NURBSSurfaceKit & SetVCount(size_t in_count);
28909 
28913  NURBSSurfaceKit & SetPoints(PointArray const & in_points);
28914 
28919  NURBSSurfaceKit & SetPoints(size_t in_count, Point const in_points []);
28920 
28925  NURBSSurfaceKit & SetWeights(FloatArray const & in_weights);
28926 
28932  NURBSSurfaceKit & SetWeights(size_t in_count, float const in_weights []);
28933 
28938  NURBSSurfaceKit & SetUKnots(FloatArray const & in_knots);
28939 
28945  NURBSSurfaceKit & SetUKnots(size_t in_count, float const in_knots []);
28946 
28951  NURBSSurfaceKit & SetVKnots(FloatArray const & in_knots);
28952 
28958  NURBSSurfaceKit & SetVKnots(size_t in_count, float const in_knots []);
28959 
28963  NURBSSurfaceKit & SetTrims(TrimKitArray const & in_trims);
28964 
28969  NURBSSurfaceKit & SetTrims(size_t in_count, TrimKit const in_trims []);
28970 
28974  NURBSSurfaceKit & SetTrim(TrimKit const & in_trim);
28975 
28976 
28979  NURBSSurfaceKit & UnsetUDegree();
28980 
28983  NURBSSurfaceKit & UnsetVDegree();
28984 
28987  NURBSSurfaceKit & UnsetUCount();
28988 
28991  NURBSSurfaceKit & UnsetVCount();
28992 
28995  NURBSSurfaceKit & UnsetPoints();
28996 
28999  NURBSSurfaceKit & UnsetWeights();
29000 
29003  NURBSSurfaceKit & UnsetUKnots();
29004 
29007  NURBSSurfaceKit & UnsetVKnots();
29008 
29011  NURBSSurfaceKit & UnsetTrims();
29012 
29015  NURBSSurfaceKit & UnsetEverything();
29016 
29017 
29021  bool ShowUDegree(size_t & out_degree) const;
29022 
29026  bool ShowVDegree(size_t & out_degree) const;
29027 
29031  bool ShowUCount(size_t & out_count) const;
29032 
29036  bool ShowVCount(size_t & out_count) const;
29037 
29041  bool ShowPoints(PointArray & out_points) const;
29042 
29048  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
29049 
29054  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
29055 
29061  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
29062 
29066  bool ShowWeights(FloatArray & out_weights) const;
29067 
29071  bool ShowUKnots(FloatArray & out_knots) const;
29072 
29076  bool ShowVKnots(FloatArray & out_knots) const;
29077 
29081  bool ShowTrims(TrimKitArray & out_trims) const;
29082 
29083 
29090  NURBSSurfaceKit & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
29091 
29097  NURBSSurfaceKit & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
29098 
29105  NURBSSurfaceKit & EditPointsByDeletion(size_t in_offset, size_t in_count);
29106 
29113  NURBSSurfaceKit & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
29114 
29121  NURBSSurfaceKit & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
29122 
29123 
29131  NURBSSurfaceKit & EditWeightsByInsertion(size_t in_offset, size_t in_count, float const in_weights[]);
29132 
29139  NURBSSurfaceKit & EditWeightsByInsertion(size_t in_offset, FloatArray const & in_weights);
29140 
29148  NURBSSurfaceKit & EditWeightsByDeletion(size_t in_offset, size_t in_count);
29149 
29156  NURBSSurfaceKit & EditWeightsByReplacement(size_t in_offset, size_t in_count, float const in_weights[]);
29157 
29164  NURBSSurfaceKit & EditWeightsByReplacement(size_t in_offset, FloatArray const & in_weights);
29165 
29166 
29173  NURBSSurfaceKit & EditUKnotsByInsertion(size_t in_offset, size_t in_count, float const in_knots[]);
29174 
29180  NURBSSurfaceKit & EditUKnotsByInsertion(size_t in_offset, FloatArray const & in_knots);
29181 
29188  NURBSSurfaceKit & EditUKnotsByDeletion(size_t in_offset, size_t in_count);
29189 
29196  NURBSSurfaceKit & EditUKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
29197 
29204  NURBSSurfaceKit & EditUKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
29205 
29206 
29213  NURBSSurfaceKit & EditVKnotsByInsertion(size_t in_offset, size_t in_count, float const in_knots[]);
29214 
29220  NURBSSurfaceKit & EditVKnotsByInsertion(size_t in_offset, FloatArray const & in_knots);
29221 
29228  NURBSSurfaceKit & EditVKnotsByDeletion(size_t in_offset, size_t in_count);
29229 
29236  NURBSSurfaceKit & EditVKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
29237 
29244  NURBSSurfaceKit & EditVKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
29245 
29251  NURBSSurfaceKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
29252 
29257  NURBSSurfaceKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
29258 
29263  NURBSSurfaceKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
29264 
29268  NURBSSurfaceKit & UnsetUserData(intptr_t in_index);
29269 
29274  NURBSSurfaceKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
29275 
29279  NURBSSurfaceKit & UnsetUserData(IntPtrTArray const & in_indices);
29280 
29283  NURBSSurfaceKit & UnsetAllUserData();
29284 
29286  size_t ShowUserDataCount() const;
29287 
29291  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
29292 
29297  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
29298 
29303  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
29304 };
29305 
29306 
29308 class HPS_API NURBSSurfaceKey : public GeometryKey
29309 {
29310 public:
29312  NURBSSurfaceKey();
29313 
29317  explicit NURBSSurfaceKey(Key const & in_that);
29318 
29321  NURBSSurfaceKey(NURBSSurfaceKey const & in_that);
29322 
29326  NURBSSurfaceKey & operator=(NURBSSurfaceKey const & in_that);
29327 
29331  NURBSSurfaceKey(NURBSSurfaceKey && in_that);
29332 
29336  NURBSSurfaceKey & operator=(NURBSSurfaceKey && in_that);
29337 
29338  ~NURBSSurfaceKey();
29339 
29340  static const HPS::Type staticType = HPS::Type::NURBSSurfaceKey;
29341  HPS::Type ObjectType() const { return staticType; };
29342 
29345  void Consume(NURBSSurfaceKit & in_kit);
29346 
29349  void Set(NURBSSurfaceKit const & in_kit);
29350 
29353  void Show(NURBSSurfaceKit & out_kit) const;
29354 
29357  size_t GetPointCount() const;
29358 
29363  NURBSSurfaceKey & SetTrims(size_t in_count, TrimKit const in_trims []);
29364 
29368  NURBSSurfaceKey & SetTrim(TrimKit const & in_trim);
29369 
29373  NURBSSurfaceKey & SetTrims(TrimKitArray const & in_trims);
29374 
29375 
29378  NURBSSurfaceKey & UnsetTrims();
29379 
29380 
29384  bool ShowUDegree(size_t & out_degree) const;
29385 
29389  bool ShowVDegree(size_t & out_degree) const;
29390 
29394  bool ShowUCount(size_t & out_count) const;
29395 
29399  bool ShowVCount(size_t & out_count) const;
29400 
29404  bool ShowPoints(PointArray & out_points) const;
29405 
29411  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
29412 
29417  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
29418 
29424  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
29425 
29429  bool ShowWeights(FloatArray & out_weights) const;
29430 
29434  bool ShowUKnots(FloatArray & out_knots) const;
29435 
29439  bool ShowVKnots(FloatArray & out_knots) const;
29440 
29444  bool ShowTrims(TrimKitArray & out_trims) const;
29445 
29446 
29454  NURBSSurfaceKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
29455 
29462  NURBSSurfaceKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
29463 
29464 
29473  NURBSSurfaceKey & EditWeightsByReplacement(size_t in_offset, size_t in_count, float const in_weights[]);
29474 
29482  NURBSSurfaceKey & EditWeightsByReplacement(size_t in_offset, FloatArray const & in_weights);
29483 
29484 
29492  NURBSSurfaceKey & EditUKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
29493 
29500  NURBSSurfaceKey & EditUKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
29501 
29502 
29510  NURBSSurfaceKey & EditVKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
29511 
29518  NURBSSurfaceKey & EditVKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
29519 };
29520 
29521 
29522 
29524 class HPS_API TrimElement : public Object
29525 {
29526 public:
29528  TrimElement();
29529 
29532  TrimElement(TrimElement const & in_that);
29533 
29537  TrimElement(LineKit const & in_line);
29538 
29542  TrimElement(NURBSCurveKit const & in_curve);
29543 
29547  TrimElement(TrimElement && in_that);
29548 
29552  TrimElement & operator=(TrimElement && in_that);
29553 
29554  ~TrimElement();
29555 
29556  static const HPS::Type staticType = HPS::Type::TrimElement;
29557  HPS::Type ObjectType() const { return staticType; };
29558 
29561  void Set(TrimElement const & in_that);
29562 
29566  TrimElement & operator=(TrimElement const & in_that);
29567 
29571  bool Equals(TrimElement const & in_that) const;
29572 
29576  bool operator==(TrimElement const & in_that) const;
29577 
29581  bool operator!=(TrimElement const & in_that) const;
29582 
29583 
29587  void SetCurve(LineKit const & in_line);
29588 
29592  void SetCurve(NURBSCurveKit const & in_curve);
29593 
29599  bool ShowCurve(Trim::Type & out_type, LineKit & out_line, NURBSCurveKit & out_curve) const;
29600 };
29601 
29602 
29603 
29605 class HPS_API TrimKit : public Kit
29606 {
29607 public:
29609  TrimKit();
29610 
29613  TrimKit(TrimKit const & in_kit);
29614 
29618  TrimKit(TrimKit && in_that);
29619 
29623  TrimKit & operator=(TrimKit && in_that);
29624 
29625  virtual ~TrimKit();
29626 
29627  static const HPS::Type staticType = HPS::Type::TrimKit;
29628  HPS::Type ObjectType() const { return staticType; };
29629 
29632  void Set(TrimKit const & in_kit);
29633 
29636  void Show(TrimKit & out_kit) const;
29637 
29641  TrimKit & operator=(TrimKit const & in_kit);
29642 
29645  bool Empty() const;
29646 
29650  bool Equals(TrimKit const & in_kit) const;
29651 
29655  bool operator==(TrimKit const & in_kit) const;
29656 
29660  bool operator!=(TrimKit const & in_kit) const;
29661 
29662 
29667  TrimKit & SetShape(size_t in_count, TrimElement const in_shape[]);
29668 
29672  TrimKit & SetShape(TrimElementArray const & in_shape);
29673 
29677  TrimKit & SetShape(TrimElement const & in_shape);
29678 
29679 
29683  TrimKit & SetOperation(Trim::Operation in_operation);
29684 
29685 
29688  TrimKit & UnsetShape();
29689 
29692  TrimKit & UnsetOperation();
29693 
29696  TrimKit & UnsetEverything();
29697 
29698 
29702  bool ShowShape(TrimElementArray & out_shape) const;
29703 
29707  bool ShowOperation(Trim::Operation & out_operation) const;
29708 };
29709 
29710 
29711 
29713 class HPS_API EllipseKit : public Kit
29714 {
29715 public:
29717  EllipseKit();
29718 
29721  EllipseKit(EllipseKit const & in_kit);
29722 
29726  EllipseKit(EllipseKit && in_that);
29727 
29731  EllipseKit & operator=(EllipseKit && in_that);
29732 
29733  virtual ~EllipseKit();
29734 
29735  static const HPS::Type staticType = HPS::Type::EllipseKit;
29736  HPS::Type ObjectType() const { return staticType; };
29737 
29740  void Consume(EllipseKit & in_kit);
29741 
29744  void Set(EllipseKit const & in_kit);
29745 
29748  void Show(EllipseKit & out_kit) const;
29749 
29753  EllipseKit & operator=(EllipseKit const & in_kit);
29754 
29757  bool Empty() const;
29758 
29762  bool Equals(EllipseKit const & in_kit) const;
29763 
29767  bool operator==(EllipseKit const & in_kit) const;
29768 
29772  bool operator!=(EllipseKit const & in_kit) const;
29773 
29780  EllipseKit & SetPriority(int in_priority);
29781 
29784  EllipseKit & UnsetPriority();
29785 
29789  bool ShowPriority(int & out_priority) const;
29790 
29791 
29795  EllipseKit & SetCenter(Point const & in_center);
29796 
29800  EllipseKit & SetMajor(Point const & in_major);
29801 
29805  EllipseKit & SetMinor(Point const & in_minor);
29806 
29807 
29810  EllipseKit & UnsetCenter();
29811 
29814  EllipseKit & UnsetMajor();
29815 
29818  EllipseKit & UnsetMinor();
29819 
29822  EllipseKit & UnsetEverything();
29823 
29824 
29828  bool ShowCenter(Point & out_center) const;
29829 
29833  bool ShowMajor(Point & out_major) const;
29834 
29838  bool ShowMinor(Point & out_minor) const;
29839 
29845  EllipseKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
29846 
29851  EllipseKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
29852 
29857  EllipseKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
29858 
29862  EllipseKit & UnsetUserData(intptr_t in_index);
29863 
29868  EllipseKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
29869 
29873  EllipseKit & UnsetUserData(IntPtrTArray const & in_indices);
29874 
29877  EllipseKit & UnsetAllUserData();
29878 
29880  size_t ShowUserDataCount() const;
29881 
29885  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
29886 
29891  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
29892 
29897  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
29898 };
29899 
29900 
29901 
29903 class HPS_API EllipseKey : public GeometryKey
29904 {
29905 public:
29907  EllipseKey();
29908 
29912  explicit EllipseKey(Key const & in_that);
29913 
29916  EllipseKey(EllipseKey const & in_that);
29917 
29921  EllipseKey & operator=(EllipseKey const & other);
29922 
29926  EllipseKey(EllipseKey && in_that);
29927 
29931  EllipseKey & operator=(EllipseKey && in_that);
29932 
29933  ~EllipseKey();
29934 
29935  static const HPS::Type staticType = HPS::Type::EllipseKey;
29936  HPS::Type ObjectType() const { return staticType; };
29937 
29940  void Consume(EllipseKit & in_kit);
29941 
29944  void Set(EllipseKit const & in_kit);
29945 
29948  void Show(EllipseKit & out_kit) const;
29949 
29950 
29954  EllipseKey & SetCenter(Point const & in_center);
29955 
29959  EllipseKey & SetMajor(Point const & in_major);
29960 
29964  EllipseKey & SetMinor(Point const & in_minor);
29965 
29966 
29970  bool ShowCenter(Point & out_center) const;
29971 
29975  bool ShowMajor(Point & out_major) const;
29976 
29980  bool ShowMinor(Point & out_minor) const;
29981 };
29982 
29983 
29984 
29986 class HPS_API EllipticalArcKit : public Kit
29987 {
29988 public:
29990  EllipticalArcKit();
29991 
29994  EllipticalArcKit(EllipticalArcKit const & in_kit);
29995 
29999  EllipticalArcKit(EllipticalArcKit && in_that);
30000 
30004  EllipticalArcKit & operator=(EllipticalArcKit && in_that);
30005 
30006  virtual ~EllipticalArcKit();
30007 
30008  static const HPS::Type staticType = HPS::Type::EllipticalArcKit;
30009  HPS::Type ObjectType() const { return staticType; };
30010 
30013  void Consume(EllipticalArcKit & in_kit);
30014 
30017  void Set(EllipticalArcKit const & in_kit);
30018 
30021  void Show(EllipticalArcKit & out_kit) const;
30022 
30026  EllipticalArcKit & operator=(EllipticalArcKit const & in_kit);
30027 
30030  bool Empty() const;
30031 
30035  bool Equals(EllipticalArcKit const & in_kit) const;
30036 
30040  bool operator==(EllipticalArcKit const & in_kit) const;
30041 
30045  bool operator!=(EllipticalArcKit const & in_kit) const;
30046 
30053  EllipticalArcKit & SetPriority(int in_priority);
30054 
30057  EllipticalArcKit & UnsetPriority();
30058 
30062  bool ShowPriority(int & out_priority) const;
30063 
30064 
30068  EllipticalArcKit & SetCenter(Point const & in_center);
30069 
30073  EllipticalArcKit & SetMajor(Point const & in_major);
30074 
30078  EllipticalArcKit & SetMinor(Point const & in_minor);
30079 
30087  EllipticalArcKit & SetStart(float in_start);
30088 
30096  EllipticalArcKit & SetEnd(float in_end);
30097 
30098 
30101  EllipticalArcKit & UnsetCenter();
30102 
30105  EllipticalArcKit & UnsetMajor();
30106 
30109  EllipticalArcKit & UnsetMinor();
30110 
30113  EllipticalArcKit & UnsetStart();
30114 
30117  EllipticalArcKit & UnsetEnd();
30118 
30121  EllipticalArcKit & UnsetEverything();
30122 
30123 
30127  bool ShowCenter(Point & out_center) const;
30128 
30132  bool ShowMajor(Point & out_major) const;
30133 
30137  bool ShowMinor(Point & out_minor) const;
30138 
30142  bool ShowStart(float & out_start) const;
30143 
30147  bool ShowEnd(float & out_end) const;
30148 
30154  EllipticalArcKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
30155 
30160  EllipticalArcKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
30161 
30166  EllipticalArcKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
30167 
30171  EllipticalArcKit & UnsetUserData(intptr_t in_index);
30172 
30177  EllipticalArcKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
30178 
30182  EllipticalArcKit & UnsetUserData(IntPtrTArray const & in_indices);
30183 
30186  EllipticalArcKit & UnsetAllUserData();
30187 
30189  size_t ShowUserDataCount() const;
30190 
30194  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
30195 
30200  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
30201 
30206  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
30207 };
30208 
30209 
30211 class HPS_API EllipticalArcKey : public GeometryKey
30212 {
30213 public:
30215  EllipticalArcKey();
30216 
30220  explicit EllipticalArcKey(Key const & in_that);
30221 
30224  EllipticalArcKey(EllipticalArcKey const & in_that);
30225 
30229  EllipticalArcKey & operator=(EllipticalArcKey const & other);
30230 
30234  EllipticalArcKey(EllipticalArcKey && in_that);
30235 
30239  EllipticalArcKey & operator=(EllipticalArcKey && in_that);
30240 
30241  ~EllipticalArcKey();
30242 
30243  static const HPS::Type staticType = HPS::Type::EllipticalArcKey;
30244  HPS::Type ObjectType() const { return staticType; };
30245 
30246 
30249  void Consume(EllipticalArcKit & in_kit);
30250 
30253  void Set(EllipticalArcKit const & in_kit);
30254 
30257  void Show(EllipticalArcKit & out_kit) const;
30258 
30259 
30263  EllipticalArcKey & SetCenter(Point const & in_center);
30264 
30268  EllipticalArcKey & SetMajor(Point const & in_major);
30269 
30273  EllipticalArcKey & SetMinor(Point const & in_minor);
30274 
30282  EllipticalArcKey & SetStart(float in_start);
30283 
30291  EllipticalArcKey & SetEnd(float in_end);
30292 
30293 
30297  bool ShowCenter(Point & out_center) const;
30298 
30302  bool ShowMajor(Point & out_major) const;
30303 
30307  bool ShowMinor(Point & out_minor) const;
30308 
30312  bool ShowStart(float & out_start) const;
30313 
30317  bool ShowEnd(float & out_end) const;
30318 };
30319 
30320 
30321 
30323 class HPS_API TextKit : public Kit
30324 {
30325 public:
30327  TextKit();
30328 
30331  TextKit(TextKit const & in_kit);
30332 
30336  TextKit(TextKit && in_that);
30337 
30341  TextKit & operator=(TextKit && in_that);
30342 
30343  virtual ~TextKit();
30344 
30345  static const HPS::Type staticType = HPS::Type::TextKit;
30346  HPS::Type ObjectType() const { return staticType; };
30347 
30350  void Consume(TextKit & in_kit);
30351 
30354  void Set(TextKit const & in_kit);
30355 
30358  void Show(TextKit & out_kit) const;
30359 
30363  TextKit & operator=(TextKit const & in_kit);
30364 
30367  bool Empty() const;
30368 
30372  bool Equals(TextKit const & in_kit) const;
30373 
30377  bool operator==(TextKit const & in_kit) const;
30378 
30382  bool operator!=(TextKit const & in_kit) const;
30383 
30390  TextKit & SetPriority(int in_priority);
30391 
30394  TextKit & UnsetPriority();
30395 
30399  bool ShowPriority(int & out_priority) const;
30400 
30404  TextKit & SetPosition(Point const & in_position);
30405 
30409  TextKit & SetText(char const * in_string);
30410 
30414  TextKit & SetColor(RGBAColor const & in_rgba_color);
30415 
30419  TextKit & SetColorByIndex(float in_index);
30420 
30424  TextKit & SetModellingMatrix(MatrixKit const & in_matrix);
30425 
30431  TextKit & SetAlignment(Text::Alignment in_alignment, Text::ReferenceFrame in_reference_frame = Text::ReferenceFrame::WorldAligned, Text::Justification in_justification = Text::Justification::Left);
30432 
30436  TextKit & SetBold(bool in_state);
30437 
30441  TextKit & SetItalic(bool in_state);
30442 
30446  TextKit & SetOverline(bool in_state);
30447 
30451  TextKit & SetStrikethrough(bool in_state);
30452 
30456  TextKit & SetUnderline(bool in_state);
30457 
30462  TextKit & SetSlant(float in_angle);
30463 
30467  TextKit & SetLineSpacing(float in_multiplier);
30468 
30474  TextKit & SetRotation(Text::Rotation in_state, float in_angle = 0.0f);
30475 
30479  TextKit & SetRotation(float in_angle);
30480 
30486  TextKit & SetExtraSpace(bool in_state, float in_size = 0.0f, Text::SizeUnits in_units = Text::SizeUnits::ObjectSpace);
30487 
30492  TextKit & SetExtraSpace(float in_size, Text::SizeUnits in_units);
30493 
30500  TextKit & SetGreeking(bool in_state, float in_size = 0.0f, Text::GreekingUnits in_units = Text::GreekingUnits::ObjectSpace, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
30501 
30507  TextKit & SetGreeking(float in_size, Text::GreekingUnits in_units, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
30508 
30517  TextKit & SetSizeTolerance(bool in_state, float in_size = 50.0f, Text::SizeToleranceUnits in_units = Text::SizeToleranceUnits::Percent);
30518 
30526  TextKit & SetSizeTolerance(float in_size, Text::SizeToleranceUnits in_units);
30527 
30532  TextKit & SetSize(float in_size, Text::SizeUnits in_units);
30533 
30539  TextKit & SetFont(char const * in_name);
30540 
30544  TextKit & SetTransform(Text::Transform in_trans);
30545 
30549  TextKit & SetRenderer(Text::Renderer in_rend);
30550 
30554  TextKit & SetPreference(Text::Preference in_pref);
30555 
30562  TextKit & SetPreference(float in_cutoff, Text::SizeUnits in_units, Text::Preference in_smaller, Text::Preference in_larger);
30563 
30567  TextKit & SetPath(Vector const & in_path);
30568 
30574  TextKit & SetSpacing(float in_multiplier);
30575 
30580  TextKit & SetBackground(bool in_state, char const * in_name);
30581 
30586  TextKit & SetBackground(char const * in_name);
30587 
30591  TextKit & SetBackground(bool in_state);
30592 
30597  TextKit & SetBackgroundMargins(float in_size, Text::MarginUnits in_units = Text::MarginUnits::Percent);
30598 
30604  TextKit & SetBackgroundMargins(FloatArray const & in_sizes, TextMarginUnitsArray const & in_units);
30605 
30612  TextKit & SetBackgroundMargins(size_t in_count, float const in_sizes [], HPS::Text::MarginUnits const in_units []);
30613 
30618  TextKit & SetBackgroundStyle(char const * in_name);
30619 
30624  TextKit & SetLeaderLine(Point const & in_position, Text::LeaderLineSpace in_space = Text::LeaderLineSpace::Object);
30625 
30630  TextKit & SetLeaderLines(PointArray const & in_positions, Text::LeaderLineSpace in_space = Text::LeaderLineSpace::Object);
30631 
30637  TextKit & SetLeaderLines(size_t in_count, Point const in_positions [], Text::LeaderLineSpace in_space = Text::LeaderLineSpace::Object);
30638 
30641  TextKit & UnsetPosition();
30642 
30645  TextKit & UnsetText();
30646 
30649  TextKit & UnsetColor();
30650 
30653  TextKit & UnsetModellingMatrix();
30654 
30657  TextKit & UnsetAlignment();
30658 
30661  TextKit & UnsetBold();
30662 
30665  TextKit & UnsetItalic();
30666 
30669  TextKit & UnsetOverline();
30670 
30673  TextKit & UnsetStrikethrough();
30674 
30677  TextKit & UnsetUnderline();
30678 
30681  TextKit & UnsetSlant();
30682 
30685  TextKit & UnsetLineSpacing();
30686 
30689  TextKit & UnsetRotation();
30690 
30693  TextKit & UnsetExtraSpace();
30694 
30697  TextKit & UnsetGreeking();
30698 
30701  TextKit & UnsetSizeTolerance();
30702 
30705  TextKit & UnsetSize();
30706 
30709  TextKit & UnsetFont();
30710 
30713  TextKit & UnsetTransform();
30714 
30717  TextKit & UnsetRenderer();
30718 
30721  TextKit & UnsetPreference();
30722 
30725  TextKit & UnsetPath();
30726 
30729  TextKit & UnsetSpacing();
30730 
30733  TextKit & UnsetBackground();
30734 
30737  TextKit & UnsetBackgroundMargins();
30738 
30741  TextKit & UnsetBackgroundStyle();
30742 
30745  TextKit & UnsetLeaderLines();
30746 
30749  TextKit & UnsetEverything();
30750 
30751 
30755  bool ShowPosition(Point & out_position) const;
30756 
30760  bool ShowText(UTF8 & out_string) const;
30761 
30767  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
30768 
30772  bool ShowModellingMatrix(MatrixKit & out_matrix) const;
30773 
30779  bool ShowAlignment(Text::Alignment & out_alignment, Text::ReferenceFrame & out_reference_frame, Text::Justification & out_justification) const;
30780 
30784  bool ShowBold(bool & out_state) const;
30785 
30789  bool ShowItalic(bool & out_state) const;
30790 
30794  bool ShowOverline(bool & out_state) const;
30795 
30799  bool ShowStrikethrough(bool & out_state) const;
30800 
30804  bool ShowUnderline(bool & out_state) const;
30805 
30809  bool ShowSlant(float & out_angle) const;
30810 
30814  bool ShowLineSpacing(float & out_multiplier) const;
30815 
30820  bool ShowRotation(Text::Rotation & out_rot, float & out_angle) const;
30821 
30827  bool ShowExtraSpace(bool & out_state, float & out_size, Text::SizeUnits & out_units) const;
30828 
30835  bool ShowGreeking(bool & out_state, float & out_size, Text::GreekingUnits & out_units, Text::GreekingMode & out_mode) const;
30836 
30842  bool ShowSizeTolerance(bool & out_state, float & out_size, Text::SizeToleranceUnits & out_units) const;
30843 
30848  bool ShowSize(float & out_size, Text::SizeUnits & out_units) const;
30849 
30853  bool ShowFont(UTF8 & out_name) const;
30854 
30858  bool ShowTransform(Text::Transform & out_trans) const;
30859 
30863  bool ShowRenderer(Text::Renderer & out_renderer) const;
30864 
30871  bool ShowPreference(float & out_cutoff, Text::SizeUnits & out_units, Text::Preference & out_smaller, Text::Preference & out_larger) const;
30872 
30876  bool ShowPath(Vector & out_path) const;
30877 
30881  bool ShowSpacing(float & out_multiplier) const;
30882 
30887  bool ShowBackground(bool & out_state, UTF8 & out_name) const;
30888 
30893  bool ShowBackgroundMargins(FloatArray & out_size, TextMarginUnitsArray & out_units) const;
30894 
30898  bool ShowBackgroundStyle(UTF8 & out_name) const;
30899 
30904  bool ShowLeaderLines(PointArray & out_positions, Text::LeaderLineSpace & out_space) const;
30905 
30913  TextKit & EditTextByInsertion(size_t in_row, size_t in_column, size_t in_count, char const * in_text);
30914 
30921  TextKit & EditTextByDeletion(size_t in_row, size_t in_column, size_t in_count);
30922 
30930  TextKit & EditTextByReplacement(size_t in_row, size_t in_column, size_t in_count, char const * in_text);
30931 
30940  bool ShowRegion(PointArray & out_region, Text::RegionAlignment & out_region_alignment, Text::RegionFitting & out_region_fitting, bool & out_region_adjust_direction, bool & out_region_relative_coordinates, bool & out_region_window_space) const;
30941 
30954  TextKit & SetRegion(PointArray const & in_region, Text::RegionAlignment in_region_alignment, Text::RegionFitting in_region_fitting, bool in_region_adjust_direction, bool in_region_relative_coordinates, bool in_region_window_space);
30955 
30969  TextKit & SetRegion(size_t in_region_count, Point const in_region [], Text::RegionAlignment in_region_alignment, Text::RegionFitting in_region_fitting, bool in_region_adjust_direction, bool in_region_relative_coordinates, bool in_region_window_space);
30970 
30976  TextKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
30977 
30980  TextKit & UnsetRegion();
30981 
30986  TextKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
30987 
30992  TextKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
30993 
30997  TextKit & UnsetUserData(intptr_t in_index);
30998 
31003  TextKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
31004 
31008  TextKit & UnsetUserData(IntPtrTArray const & in_indices);
31009 
31012  TextKit & UnsetAllUserData();
31013 
31015  size_t ShowUserDataCount() const;
31016 
31020  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
31021 
31026  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
31027 
31032  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
31033 };
31034 
31035 
31037 class HPS_API TextKey : public GeometryKey
31038 {
31039 public:
31041  TextKey();
31042 
31046  explicit TextKey(Key const & in_that);
31047 
31050  TextKey(TextKey const & in_that);
31051 
31055  TextKey & operator=(TextKey const & other);
31056 
31060  TextKey(TextKey && in_that);
31061 
31065  TextKey & operator=(TextKey && in_that);
31066 
31067  ~TextKey();
31068 
31069  static const HPS::Type staticType = HPS::Type::TextKey;
31070  HPS::Type ObjectType() const {return staticType;};
31071 
31074  void Consume(TextKit & in_kit);
31075 
31078  void Set(TextKit const & in_kit);
31079 
31082  void Show(TextKit & out_kit) const;
31083 
31086  TextKey & SetTextAttribute(TextAttributeKit const & in_kit);
31087 
31091  bool ShowTextAttribute(TextAttributeKit & out_kit) const;
31092 
31096  TextKey & SetPosition(Point const & in_position);
31097 
31101  TextKey & SetText(char const * in_string);
31102 
31106  TextKey & SetColor(RGBAColor const & in_rgba_color);
31107 
31111  TextKey & SetColorByIndex(float in_index);
31112 
31116  TextKey & SetModellingMatrix(MatrixKit const & in_matrix);
31117 
31123  TextKey & SetAlignment(Text::Alignment in_alignment, Text::ReferenceFrame in_reference_frame = Text::ReferenceFrame::WorldAligned, Text::Justification in_justification = Text::Justification::Left);
31124 
31128  TextKey & SetBold(bool in_state);
31129 
31133  TextKey & SetItalic(bool in_state);
31134 
31138  TextKey & SetOverline(bool in_state);
31139 
31143  TextKey & SetStrikethrough(bool in_state);
31144 
31148  TextKey & SetUnderline(bool in_state);
31149 
31154  TextKey & SetSlant(float in_angle);
31155 
31160  TextKey & SetLineSpacing(float in_multiplier);
31161 
31167  TextKey & SetRotation(Text::Rotation in_state, float in_angle = 0.0f);
31168 
31172  TextKey & SetRotation(float in_angle);
31173 
31179  TextKey & SetExtraSpace(bool in_state, float in_size = 0.0f, Text::SizeUnits in_units = Text::SizeUnits::ObjectSpace);
31180 
31185  TextKey & SetExtraSpace(float in_size, Text::SizeUnits in_units);
31186 
31193  TextKey & SetGreeking(bool in_state, float in_size = 0.0f, Text::GreekingUnits in_units = Text::GreekingUnits::ObjectSpace, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
31194 
31200  TextKey & SetGreeking(float in_size, Text::GreekingUnits in_units, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
31201 
31210  TextKey & SetSizeTolerance(bool in_state, float in_size = 50.0f, Text::SizeToleranceUnits in_units = Text::SizeToleranceUnits::Percent);
31211 
31219  TextKey & SetSizeTolerance(float in_size, Text::SizeToleranceUnits in_units);
31220 
31225  TextKey & SetSize(float in_size, Text::SizeUnits in_units);
31226 
31232  TextKey & SetFont(char const * in_name);
31233 
31237  TextKey & SetTransform(Text::Transform in_transform);
31238 
31242  TextKey & SetRenderer(Text::Renderer in_renderer);
31243 
31247  TextKey & SetPreference(Text::Preference in_preference);
31248 
31256  TextKey & SetPreference(float in_cutoff, Text::SizeUnits in_units, Text::Preference in_smaller, Text::Preference in_larger);
31257 
31262  TextKey & SetPath(Vector const & in_path);
31263 
31269  TextKey & SetSpacing(float in_multiplier);
31270 
31283  TextKey & SetRegion(PointArray const & in_region, Text::RegionAlignment in_region_alignment, Text::RegionFitting in_region_fitting, bool in_region_adjust_direction, bool in_region_relative_coordinates, bool in_region_window_space);
31284 
31298  TextKey & SetRegion(size_t in_region_count, Point const in_region [], Text::RegionAlignment in_region_alignment, Text::RegionFitting in_region_fitting, bool in_region_adjust_direction, bool in_region_relative_coordinates, bool in_region_window_space);
31299 
31304  TextKey & SetBackground(bool in_state, char const * in_name);
31305 
31310  TextKey & SetBackground(char const * in_name);
31311 
31315  TextKey & SetBackground(bool in_state);
31316 
31321  TextKey & SetBackgroundMargins(float in_size, Text::MarginUnits in_units = Text::MarginUnits::Percent);
31322 
31328  TextKey & SetBackgroundMargins(FloatArray const & in_sizes, TextMarginUnitsArray const & in_units);
31329 
31336  TextKey & SetBackgroundMargins(size_t in_count, float const in_sizes [], HPS::Text::MarginUnits const in_units []);
31337 
31342  TextKey & SetBackgroundStyle(char const * in_name);
31343 
31348  TextKey & SetLeaderLine(Point const & in_position, Text::LeaderLineSpace in_space = Text::LeaderLineSpace::Object);
31349 
31354  TextKey & SetLeaderLines(PointArray const & in_positions, Text::LeaderLineSpace in_space = Text::LeaderLineSpace::Object);
31355 
31361  TextKey & SetLeaderLines(size_t in_count, Point const in_positions [], Text::LeaderLineSpace in_space = Text::LeaderLineSpace::Object);
31362 
31363 
31366  TextKey & UnsetColor();
31367 
31370  TextKey & UnsetModellingMatrix();
31371 
31374  TextKey & UnsetAlignment();
31375 
31378  TextKey & UnsetBold();
31379 
31382  TextKey & UnsetItalic();
31383 
31386  TextKey & UnsetOverline();
31387 
31390  TextKey & UnsetStrikethrough();
31391 
31394  TextKey & UnsetUnderline();
31395 
31398  TextKey & UnsetSlant();
31399 
31402  TextKey & UnsetLineSpacing();
31403 
31406  TextKey & UnsetRotation();
31407 
31410  TextKey & UnsetExtraSpace();
31411 
31414  TextKey & UnsetGreeking();
31415 
31418  TextKey & UnsetSizeTolerance();
31419 
31422  TextKey & UnsetSize();
31423 
31426  TextKey & UnsetFont();
31427 
31430  TextKey & UnsetTransform();
31431 
31434  TextKey & UnsetRenderer();
31435 
31438  TextKey & UnsetPreference();
31439 
31442  TextKey & UnsetPath();
31443 
31446  TextKey & UnsetSpacing();
31447 
31450  TextKey & UnsetRegion();
31451 
31454  TextKey & UnsetBackground();
31455 
31458  TextKey & UnsetBackgroundMargins();
31459 
31462  TextKey & UnsetBackgroundStyle();
31463 
31466  TextKey & UnsetLeaderLines();
31467 
31470  TextKey & UnsetEverything();
31471 
31472 
31476  bool ShowPosition(Point & out_position) const;
31477 
31481  bool ShowText(UTF8 & out_string) const;
31482 
31488  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
31489 
31493  bool ShowModellingMatrix(MatrixKit & out_matrix) const;
31494 
31500  bool ShowAlignment(Text::Alignment & out_alignment, Text::ReferenceFrame & out_reference_frame, Text::Justification & out_justification) const;
31501 
31505  bool ShowBold(bool & out_state) const;
31506 
31510  bool ShowItalic(bool & out_state) const;
31511 
31515  bool ShowOverline(bool & out_state) const;
31516 
31520  bool ShowStrikethrough(bool & out_state) const;
31521 
31525  bool ShowUnderline(bool & out_state) const;
31526 
31530  bool ShowSlant(float & out_angle) const;
31531 
31535  bool ShowLineSpacing(float & out_multiplier) const;
31536 
31541  bool ShowRotation(Text::Rotation & out_rot, float & out_angle) const;
31542 
31548  bool ShowExtraSpace(bool & out_state, float & out_size, Text::SizeUnits & out_units) const;
31549 
31556  bool ShowGreeking(bool & out_state, float & out_size, Text::GreekingUnits & out_units, Text::GreekingMode & out_mode) const;
31557 
31563  bool ShowSizeTolerance(bool & out_state, float & out_size, Text::SizeToleranceUnits & out_units) const;
31564 
31569  bool ShowSize(float & out_size, Text::SizeUnits & out_units) const;
31570 
31574  bool ShowFont(UTF8 & out_name) const;
31575 
31579  bool ShowTransform(Text::Transform & out_trans) const;
31580 
31584  bool ShowRenderer(Text::Renderer & out_renderer) const;
31585 
31592  bool ShowPreference(float & out_cutoff, Text::SizeUnits & out_units, Text::Preference & out_smaller, Text::Preference & out_larger) const;
31593 
31597  bool ShowPath(Vector & out_path) const;
31598 
31602  bool ShowSpacing(float & out_multiplier) const;
31603 
31612  bool ShowRegion(PointArray & out_region, Text::RegionAlignment & out_region_alignment, Text::RegionFitting & out_region_fitting, bool & out_region_adjust_direction, bool & out_region_relative_coordinates, bool & out_region_window_space) const;
31613 
31618  bool ShowBackground(bool & out_state, UTF8 & out_name) const;
31619 
31624  bool ShowBackgroundMargins(FloatArray & out_size, TextMarginUnitsArray & out_units) const;
31625 
31629  bool ShowBackgroundStyle(UTF8 & out_name) const;
31630 
31635  bool ShowLeaderLines(PointArray & out_positions, Text::LeaderLineSpace & out_space) const;
31636 
31644  TextKey & EditTextByInsertion(size_t in_row, size_t in_column, size_t in_count, char const * in_text);
31645 
31652  TextKey & EditTextByDeletion(size_t in_row, size_t in_column, size_t in_count);
31653 
31661  TextKey & EditTextByReplacement(size_t in_row, size_t in_column, size_t in_count, char const * in_text);
31662 };
31663 
31664 
31666 class HPS_API ShellOptimizationOptionsKit : public Kit
31667 {
31668 public:
31671 
31675 
31680 
31681  virtual ~ShellOptimizationOptionsKit();
31682 
31683  static const HPS::Type staticType = HPS::Type::ShellOptimizationOptionsKit;
31684  HPS::Type ObjectType() const { return staticType; };
31685 
31688  void Consume(ShellOptimizationOptionsKit & in_kit);
31689 
31692  void Set(ShellOptimizationOptionsKit const & in_kit);
31693 
31696  void Show(ShellOptimizationOptionsKit & out_kit) const;
31697 
31701  ShellOptimizationOptionsKit & operator=(ShellOptimizationOptionsKit const & in_kit);
31702 
31707 
31710  bool Empty() const;
31711 
31715  bool Equals(ShellOptimizationOptionsKit const & in_kit) const;
31716 
31720  bool operator==(ShellOptimizationOptionsKit const & in_kit) const;
31721 
31725  bool operator!=(ShellOptimizationOptionsKit const & in_kit) const;
31726 
31730  static ShellOptimizationOptionsKit GetDefault();
31731 
31732 
31736  ShellOptimizationOptionsKit & SetNormalTolerance(float in_normal_tolerance);
31737 
31742  ShellOptimizationOptionsKit & SetTolerance(float in_tolerance, Shell::ToleranceUnits in_tolerance_units);
31743 
31748  ShellOptimizationOptionsKit & SetOrphanElimination(bool in_orphan_elimination);
31749 
31754  ShellOptimizationOptionsKit & SetHandednessOptimization(Shell::HandednessOptimization in_handedness_option);
31755 
31756 
31759  ShellOptimizationOptionsKit & UnsetNormalTolerance();
31760 
31763  ShellOptimizationOptionsKit & UnsetTolerance();
31764 
31767  ShellOptimizationOptionsKit & UnsetOrphanElimination();
31768 
31771  ShellOptimizationOptionsKit & UnsetHandednessOptimization();
31772 
31775  ShellOptimizationOptionsKit & UnsetEverything();
31776 
31777 
31781  bool ShowNormalTolerance(float & out_normal_tolerance) const;
31782 
31787  bool ShowTolerance(float & out_tolerance, Shell::ToleranceUnits & out_tolerance_units) const;
31788 
31792  bool ShowOrphanElimination(bool & out_orphan_elimination) const;
31793 
31798  bool ShowHandednessOptimization(Shell::HandednessOptimization & out_handedness_option) const;
31799 };
31800 
31801 
31805 class HPS_API ShellRelationOptionsKit : public Kit
31806 {
31807 public:
31810 
31814 
31819 
31823  ShellRelationOptionsKit & operator=(ShellRelationOptionsKit && in_that);
31824 
31825  virtual ~ShellRelationOptionsKit();
31826 
31827  static const HPS::Type staticType = HPS::Type::ShellRelationOptionsKit;
31828  HPS::Type ObjectType() const { return staticType; };
31829 
31833  static ShellRelationOptionsKit GetDefault();
31834 
31837  void Consume(ShellRelationOptionsKit & in_kit);
31838 
31841  void Set(ShellRelationOptionsKit const & in_kit);
31842 
31845  void Show(ShellRelationOptionsKit & out_kit) const;
31846 
31850  ShellRelationOptionsKit & operator=(ShellRelationOptionsKit const & in_kit);
31851 
31854  bool Empty() const;
31855 
31859  bool Equals(ShellRelationOptionsKit const & in_kit) const;
31860 
31864  bool operator==(ShellRelationOptionsKit const & in_kit) const;
31865 
31869  bool operator!=(ShellRelationOptionsKit const & in_kit) const;
31870 
31871 
31875  ShellRelationOptionsKit & SetTolerance(float in_tolerance);
31876 
31880  ShellRelationOptionsKit & SetTest(Shell::RelationTest in_test);
31881 
31886  ShellRelationOptionsKit & SetTreeContext(TreeContext const & in_tree_context);
31887 
31891  ShellRelationOptionsKit & SetNearestFaceCalculation(bool in_state);
31892 
31893 
31896  ShellRelationOptionsKit & UnsetTolerance();
31897 
31900  ShellRelationOptionsKit & UnsetTest();
31901 
31904  ShellRelationOptionsKit & UnsetTreeContext();
31905 
31908  ShellRelationOptionsKit & UnsetNearestFaceCalculation();
31909 
31912  ShellRelationOptionsKit & UnsetEverything();
31913 
31914 
31918  bool ShowTolerance(float & out_tolerance) const;
31919 
31923  bool ShowTest(Shell::RelationTest & out_test) const;
31924 
31928  bool ShowTreeContext(TreeContext & out_tree_context) const;
31929 
31933  bool ShowNearestFaceCalculation(bool & out_state) const;
31934 };
31935 
31937 class HPS_API ShellRelationResultsKit : public Kit
31938 {
31939 public:
31942 
31946 
31951 
31955  ShellRelationResultsKit & operator=(ShellRelationResultsKit && in_that);
31956 
31957  virtual ~ShellRelationResultsKit();
31958 
31959  static const HPS::Type staticType = HPS::Type::ShellRelationResultsKit;
31960  HPS::Type ObjectType() const { return staticType; };
31961 
31964  void Consume(ShellRelationResultsKit & in_kit);
31965 
31968  void Set(ShellRelationResultsKit const & in_kit);
31969 
31972  void Show(ShellRelationResultsKit & out_kit) const;
31973 
31977  ShellRelationResultsKit & operator=(ShellRelationResultsKit const & in_kit);
31978 
31981  bool Empty() const;
31982 
31986  bool Equals(ShellRelationResultsKit const & in_kit) const;
31987 
31991  bool operator==(ShellRelationResultsKit const & in_kit) const;
31992 
31996  bool operator!=(ShellRelationResultsKit const & in_kit) const;
31997 
31998 
32002  bool ShowRelations(ShellRelationArray & out_results) const;
32003 
32007  bool ShowNearestFaces(SizeTArray & out_faces) const;
32008 
32012  bool ShowDistances(FloatArray & out_distances) const;
32013 };
32014 
32015 
32017 class HPS_API ShellKit : public Kit
32018 {
32019 public:
32021  ShellKit();
32022 
32025  ShellKit(ShellKit const & in_kit);
32026 
32030  ShellKit(ShellKit && in_that);
32031 
32035  ShellKit & operator=(ShellKit && in_that);
32036 
32037  virtual ~ShellKit();
32038 
32039  static const HPS::Type staticType = HPS::Type::ShellKit;
32040  HPS::Type ObjectType() const { return staticType; };
32041 
32044  void Consume(ShellKit & in_kit);
32045 
32048  void Set(ShellKit const & in_kit);
32049 
32052  void Show(ShellKit & out_kit) const;
32053 
32056  size_t GetPointCount() const;
32057 
32060  size_t GetFaceCount() const;
32061 
32065  ShellKit & operator=(ShellKit const & in_kit);
32066 
32069  bool Empty() const;
32070 
32074  bool Equals(ShellKit const & in_kit) const;
32075 
32079  bool operator==(ShellKit const & in_kit) const;
32080 
32084  bool operator!=(ShellKit const & in_kit) const;
32085 
32092  ShellKit & SetPriority(int in_priority);
32093 
32096  ShellKit & UnsetPriority();
32097 
32101  bool ShowPriority(int & out_priority) const;
32102 
32103 
32104 
32108  ShellKit & SetPoints(PointArray const & in_points);
32109 
32114  ShellKit & SetPoints(size_t in_count, Point const in_points []);
32115 
32119  ShellKit & SetFacelist(IntArray const & in_facelist);
32120 
32125  ShellKit & SetFacelist(size_t in_count, int const in_facelist []);
32126 
32130  ShellKit & SetTristrips(IntArray const & in_tristrips);
32131 
32136  ShellKit & SetTristrips(size_t in_count, int const in_tristrips []);
32137 
32140  ShellKit & UnsetPoints();
32141 
32144  ShellKit & UnsetFacelist();
32145 
32148  ShellKit & UnsetTristrips();
32149 
32152  ShellKit & UnsetEverything();
32153 
32157  bool ShowPoints(PointArray & out_points) const;
32158 
32164  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
32165 
32170  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
32171 
32177  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
32178 
32182  bool ShowFacelist(IntArray & out_facelist) const;
32183 
32187  bool ShowTristrips(IntArray & out_tristrips) const;
32188 
32194  ShellKit & SetMaterialMapping(MaterialMappingKit const & in_kit);
32195 
32202  ShellKit & SetEdgeVisibilitiesByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], bool const in_visibilities[]);
32203 
32210  ShellKit & SetEdgeVisibilitiesByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], bool in_visibility);
32211 
32217  ShellKit & SetEdgeVisibilitiesByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, bool in_visibility);
32218 
32224  ShellKit & SetEdgeVisibilitiesByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, BoolArray const & in_visibilities);
32225 
32231  ShellKit & SetEdgeIndexColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, FloatArray const & in_indices);
32232 
32238  ShellKit & SetEdgeIndexColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, float in_index);
32239 
32246  ShellKit & SetEdgeIndexColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], float const in_indices[]);
32247 
32254  ShellKit & SetEdgeIndexColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], float in_index);
32255 
32261  ShellKit & SetEdgeRGBColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, RGBColorArray const & in_rgb_colors);
32262 
32268  ShellKit & SetEdgeRGBColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, RGBColor const & in_rgb_color);
32269 
32276  ShellKit & SetEdgeRGBColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], RGBColor const in_rgb_colors[]);
32277 
32284  ShellKit & SetEdgeRGBColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], RGBColor const in_rgb_color);
32285 
32293  bool ShowEdgeColors(SizeTArray & out_vertices1, SizeTArray & out_vertices2, HPS::MaterialTypeArray & out_types, HPS::RGBColorArray & out_rgb_colors, HPS::FloatArray & out_indices);
32294 
32302  bool ShowEdgeColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, HPS::MaterialTypeArray & out_types, HPS::RGBColorArray & out_rgb_colors, HPS::FloatArray & out_indices);
32303 
32311  ShellKit & UnsetEdgeColors();
32312 
32317  ShellKit & UnsetEdgeColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2);
32318 
32324  ShellKit & UnsetEdgeColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[]);
32325 
32328  ShellKit & UnsetEdgeVisibilities();
32329 
32332  ShellKit & UnsetEdgeEverything();
32333 
32338  ShellKit & UnsetEdgeVisibilitiesByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2);
32339 
32345  ShellKit & UnsetEdgeVisibilitiesByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[]);
32346 
32347 
32356  bool ShowEdgeVisibilitiesByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, BoolArray & out_validities, BoolArray & out_visibilities) const;
32357 
32364  ShellKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
32365 
32371  ShellKit & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Shell::Component in_apply_to = Shell::Component::Faces);
32372 
32379  ShellKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
32380 
32387  ShellKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
32388 
32395  ShellKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Shell::Component in_apply_to = Shell::Component::Faces);
32396 
32403  ShellKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
32404 
32410  ShellKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
32411 
32412 
32419  ShellKit & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const in_rgba_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
32420 
32426  ShellKit & SetVertexRGBAColorsByRange(size_t in_start, RGBAColorArray const & in_rgba_colors, Shell::Component in_apply_to = Shell::Component::Faces);
32427 
32434  ShellKit & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
32435 
32442  ShellKit & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const in_rgba_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
32443 
32450  ShellKit & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColorArray const & in_rgba_colors, Shell::Component in_apply_to = Shell::Component::Faces);
32451 
32458  ShellKit & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
32459 
32465  ShellKit & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
32466 
32467 
32474  ShellKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Shell::Component in_apply_to = Shell::Component::Faces);
32475 
32481  ShellKit & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Shell::Component in_apply_to = Shell::Component::Faces);
32482 
32489  ShellKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
32490 
32497  ShellKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Shell::Component in_apply_to = Shell::Component::Faces);
32498 
32505  ShellKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Shell::Component in_apply_to = Shell::Component::Faces);
32506 
32513  ShellKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
32514 
32520  ShellKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
32521 
32522 
32528  ShellKit & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
32529 
32534  ShellKit & SetVertexNormalsByRange(size_t in_start, VectorArray const & in_normals);
32535 
32541  ShellKit & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
32542 
32548  ShellKit & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const in_normals[]);
32549 
32554  ShellKit & SetVertexNormalsByList(SizeTArray const & in_vertices, VectorArray const & in_normals);
32555 
32561  ShellKit & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const & in_normal);
32562 
32567  ShellKit & SetVertexNormalsByList(SizeTArray const & in_vertices, Vector const & in_normal);
32568 
32569 
32576  ShellKit & SetVertexParametersByRange(size_t in_start, size_t in_param_count, float const in_params[], size_t in_param_width=2);
32577 
32584  ShellKit & SetVertexParametersByRange(size_t in_start, FloatArray const & in_params, size_t in_param_width=2);
32585 
32594  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);
32595 
32603  ShellKit & SetVertexParametersByList(SizeTArray const & in_vertices, FloatArray const & in_params, size_t in_param_width=2);
32604 
32605 
32611  ShellKit & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
32612 
32617  ShellKit & SetVertexVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
32618 
32624  ShellKit & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
32625 
32631  ShellKit & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool const in_visibilities[]);
32632 
32637  ShellKit & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray const & in_visibilities);
32638 
32644  ShellKit & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool in_visibility);
32645 
32650  ShellKit & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, bool in_visibility);
32651 
32652 
32655  ShellKit & UnsetMaterialMapping();
32656 
32657 
32660  ShellKit & UnsetVertexColors();
32661 
32666  ShellKit & UnsetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[]);
32667 
32672  ShellKit & UnsetVertexColorsByList(size_t in_count, size_t const in_vertices[]);
32673 
32679  ShellKit & UnsetVertexColorsByList(size_t in_count, size_t const in_vertices[], Shell::Component in_apply_to);
32680 
32685  ShellKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
32686 
32690  ShellKit & UnsetVertexColorsByList(SizeTArray const & in_vertices);
32691 
32692 
32696  ShellKit & UnsetVertexColors(Shell::Component in_apply_to);
32697 
32703  ShellKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Shell::Component in_apply_to);
32704 
32709  ShellKit & UnsetVertexColorsByList(SizeTArray const & in_vertices, Shell::Component in_apply_to);
32710 
32711 
32714  ShellKit & UnsetVertexNormals();
32715 
32720  ShellKit & UnsetVertexNormalsByRange(size_t in_start, size_t in_count);
32721 
32725  ShellKit & UnsetVertexNormalsByList(SizeTArray const & in_vertices);
32726 
32727 
32730  ShellKit & UnsetVertexParameters();
32731 
32736  ShellKit & UnsetVertexParametersByRange(size_t in_start, size_t in_count);
32737 
32741  ShellKit & UnsetVertexParametersByList(SizeTArray const & in_vertices);
32742 
32743 
32746  ShellKit & UnsetVertexVisibilities();
32747 
32752  ShellKit & UnsetVertexVisibilitiesByRange(size_t in_start, size_t in_count);
32753 
32757  ShellKit & UnsetVertexVisibilitiesByList(SizeTArray const & in_vertices);
32758 
32759 
32762  ShellKit & UnsetVertexEverything();
32763 
32764 
32768  bool ShowMaterialMapping(MaterialMappingKit & out_kit) const;
32769 
32770 
32782  bool ShowVertexColors(Shell::Component in_apply_to, MaterialTypeArray & out_types,
32783  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
32784 
32798  bool ShowVertexColorsByRange(size_t in_start, size_t in_count, Shell::Component in_apply_to, MaterialTypeArray & out_types,
32799  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
32800 
32815  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Shell::Component in_apply_to, MaterialTypeArray & out_types,
32816  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
32817 
32824  bool ShowVertexNormals(BoolArray & out_validities, VectorArray & out_normals) const;
32825 
32834  bool ShowVertexNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
32835 
32844  bool ShowVertexNormalsByList(SizeTArray const & in_vertices, BoolArray & out_validities, VectorArray & out_normals) const;
32845 
32846 
32854  bool ShowVertexParameters(BoolArray & out_validities, FloatArray & out_params) const;
32855 
32863  bool ShowVertexParameters(BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
32864 
32874  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params) const;
32875 
32885  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
32886 
32896  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params) const;
32897 
32907  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
32908 
32909 
32916  bool ShowVertexVisibilities(BoolArray & out_validities, BoolArray & out_visibilities) const;
32917 
32926  bool ShowVertexVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
32927 
32936  bool ShowVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities) const;
32937 
32938 
32939 
32945  ShellKit & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[]);
32946 
32951  ShellKit & SetFaceRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors);
32952 
32958  ShellKit & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color);
32959 
32965  ShellKit & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const in_rgb_colors[]);
32966 
32971  ShellKit & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColorArray const & in_rgb_colors);
32972 
32978  ShellKit & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const & in_rgb_color);
32979 
32984  ShellKit & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColor const & in_rgb_color);
32985 
32986 
32992  ShellKit & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[]);
32993 
32998  ShellKit & SetFaceIndexColorsByRange(size_t in_start, FloatArray const & in_indices);
32999 
33005  ShellKit & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float in_index);
33006 
33012  ShellKit & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float const in_indices[]);
33013 
33018  ShellKit & SetFaceIndexColorsByList(SizeTArray const & in_faces, FloatArray const & in_indices);
33019 
33025  ShellKit & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float in_index);
33026 
33031  ShellKit & SetFaceIndexColorsByList(SizeTArray const & in_faces, float in_index);
33032 
33033 
33039  ShellKit & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
33040 
33045  ShellKit & SetFaceNormalsByRange(size_t in_start, VectorArray const & in_normals);
33046 
33052  ShellKit & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
33053 
33059  ShellKit & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const in_normals[]);
33060 
33065  ShellKit & SetFaceNormalsByList(SizeTArray const & in_faces, VectorArray const & in_normals);
33066 
33072  ShellKit & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const & in_normal);
33073 
33078  ShellKit & SetFaceNormalsByList(SizeTArray const & in_faces, Vector const & in_normal);
33079 
33080 
33086  ShellKit & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
33087 
33092  ShellKit & SetFaceVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
33093 
33099  ShellKit & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
33100 
33106  ShellKit & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool const in_visibilities[]);
33107 
33112  ShellKit & SetFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray const & in_visibilities);
33113 
33119  ShellKit & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool in_visibility);
33120 
33125  ShellKit & SetFaceVisibilitiesByList(SizeTArray const & in_faces, bool in_visibility);
33126 
33127 
33130  ShellKit & UnsetFaceColors();
33131 
33136  ShellKit & UnsetFaceColorsByRange(size_t in_start, size_t in_count);
33137 
33141  ShellKit & UnsetFaceColorsByList(SizeTArray const & in_faces);
33142 
33143 
33146  ShellKit & UnsetFaceNormals();
33147 
33152  ShellKit & UnsetFaceNormalsByRange(size_t in_start, size_t in_count);
33153 
33157  ShellKit & UnsetFaceNormalsByList(SizeTArray const & in_vertices);
33158 
33159 
33162  ShellKit & UnsetFaceVisibilities();
33163 
33168  ShellKit & UnsetFaceVisibilitiesByRange(size_t in_start, size_t in_count);
33169 
33173  ShellKit & UnsetFaceVisibilitiesByList(SizeTArray const & in_vertices);
33174 
33179  ShellKit & UnsetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[]);
33180 
33185  ShellKit & UnsetFaceColorsByList(size_t in_count, size_t const in_faces[]);
33186 
33189  ShellKit & UnsetFaceEverything();
33190 
33198  bool ShowFaceColors(MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
33199 
33209  bool ShowFaceColorsByRange(size_t in_start, size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
33210 
33221  bool ShowFaceColorsByList(SizeTArray const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
33222 
33223 
33230  bool ShowFaceNormals(BoolArray & out_validities, VectorArray & out_normals) const;
33231 
33240  bool ShowFaceNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
33241 
33250  bool ShowFaceNormalsByList(SizeTArray const & in_faces, BoolArray & out_validities, VectorArray & out_normals) const;
33251 
33258  bool ShowFaceVisibilities(BoolArray & out_validities, BoolArray & out_visibilities) const;
33259 
33268  bool ShowFaceVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
33269 
33278  bool ShowFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities) const;
33279 
33280 
33287  ShellKit & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
33288 
33294  ShellKit & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
33295 
33301  ShellKit & EditPointsByDeletion(size_t in_offset, size_t in_count);
33302 
33308  ShellKit & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
33309 
33315  ShellKit & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
33316 
33317 
33324  ShellKit & EditFacelistByInsertion(size_t in_offset, size_t in_count, int const in_facelist[]);
33325 
33331  ShellKit & EditFacelistByInsertion(size_t in_offset, IntArray const & in_facelist);
33332 
33338  ShellKit & EditFacelistByDeletion(size_t in_offset, size_t in_count);
33339 
33348  ShellKit & EditFacelistByReplacement(size_t in_offset, size_t in_count, int const in_facelist[]);
33349 
33357  ShellKit & EditFacelistByReplacement(size_t in_offset, IntArray const & in_facelist);
33358 
33361  void Optimize(ShellOptimizationOptionsKit const & in_shell_optimization_kit);
33362 
33367  void ComputeRelation(PointArray const & in_points, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
33368 
33373  void ComputeRelation(ShellKey const & in_points_source, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
33374 
33379  void ComputeRelation(ShellKit const & in_points_source, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
33380 
33386  ShellKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
33387 
33392  ShellKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
33393 
33398  ShellKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
33399 
33403  ShellKit & UnsetUserData(intptr_t in_index);
33404 
33409  ShellKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
33410 
33414  ShellKit & UnsetUserData(IntPtrTArray const & in_indices);
33415 
33418  ShellKit & UnsetAllUserData();
33419 
33421  size_t ShowUserDataCount() const;
33422 
33426  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
33427 
33432  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
33433 
33438  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
33439 };
33440 
33441 
33442 
33444 class HPS_API ShellKey : public GeometryKey
33445 {
33446 public:
33448  ShellKey();
33449 
33454  explicit ShellKey(Key const & in_that);
33455 
33458  ShellKey(ShellKey const & in_that);
33459 
33463  ShellKey & operator=(ShellKey const & other);
33464 
33468  ShellKey(ShellKey && in_that);
33469 
33473  ShellKey & operator=(ShellKey && in_that);
33474 
33475  ~ShellKey();
33476 
33477  static const HPS::Type staticType = HPS::Type::ShellKey;
33478  HPS::Type ObjectType() const { return staticType; };
33479 
33482  void Consume(ShellKit & in_kit);
33483 
33486  void Set(ShellKit const & in_kit);
33487 
33490  void Show(ShellKit & out_kit) const;
33491 
33494  size_t GetPointCount() const;
33495 
33498  size_t GetFaceCount() const;
33499 
33500 
33504  ShellKey & SetPoints(PointArray const & in_points);
33505 
33510  ShellKey & SetPoints(size_t in_count, Point const in_points []);
33511 
33515  ShellKey & SetFacelist(IntArray const & in_facelist);
33516 
33521  ShellKey & SetFacelist(size_t in_count, int const in_facelist []);
33522 
33526  ShellKey & SetTristrips(IntArray const & in_tristrips);
33527 
33532  ShellKey & SetTristrips(size_t in_count, int const in_tristrips []);
33533 
33538  ShellKey & SetMaterialMapping(MaterialMappingKit const & in_kit);
33539 
33542  ShellKey & UnsetPoints();
33543 
33546  ShellKey & UnsetFacelist();
33547 
33550  ShellKey & UnsetTristrips();
33551 
33554  ShellKey & UnsetMaterialMapping();
33555 
33558  ShellKey & UnsetEverything();
33559 
33563  bool ShowPoints(PointArray & out_points) const;
33564 
33570  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
33571 
33576  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
33577 
33583  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
33584 
33588  bool ShowFacelist(IntArray & out_facelist) const;
33589 
33593  bool ShowTristrips(IntArray & out_tristrips) const;
33594 
33599  bool ShowTristrips(IntArray & out_tristrips, IntArray & out_face_indices) const;
33600 
33604  bool ShowMaterialMapping(MaterialMappingKit & out_kit) const;
33605 
33612  ShellKey & SetEdgeVisibilitiesByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], bool const in_visibilities[]);
33613 
33620  ShellKey & SetEdgeVisibilitiesByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], bool in_visibility);
33621 
33627  ShellKey & SetEdgeVisibilitiesByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, bool in_visibility);
33628 
33634  ShellKey & SetEdgeVisibilitiesByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, BoolArray const & in_visibilities);
33635 
33641  ShellKey & SetEdgeIndexColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, FloatArray const & in_indices);
33642 
33648  ShellKey & SetEdgeIndexColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, float in_index);
33649 
33656  ShellKey & SetEdgeIndexColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], float const in_indices[]);
33657 
33664  ShellKey & SetEdgeIndexColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], float in_index);
33665 
33671  ShellKey & SetEdgeRGBColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, RGBColorArray const & in_rgb_colors);
33672 
33678  ShellKey & SetEdgeRGBColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, RGBColor const & in_rgb_color);
33679 
33686  ShellKey & SetEdgeRGBColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], RGBColor const in_rgb_colors[]);
33687 
33694  ShellKey & SetEdgeRGBColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], RGBColor const in_rgb_color);
33695 
33703  bool ShowEdgeColors(SizeTArray & out_vertices1, SizeTArray & out_vertices2, HPS::MaterialTypeArray & out_types, HPS::RGBColorArray & out_rgb_colors, HPS::FloatArray & out_indices);
33704 
33712  bool ShowEdgeColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, HPS::MaterialTypeArray & out_types, HPS::RGBColorArray & out_rgb_colors, HPS::FloatArray & out_indices);
33713 
33721  ShellKey & UnsetEdgeColors();
33722 
33727  ShellKey & UnsetEdgeColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2);
33728 
33734  ShellKey & UnsetEdgeColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[]);
33735 
33738  ShellKey & UnsetEdgeVisibilities();
33739 
33742  ShellKey & UnsetEdgeEverything();
33743 
33748  ShellKey & UnsetEdgeVisibilitiesByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2);
33749 
33755  ShellKey & UnsetEdgeVisibilitiesByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[]);
33756 
33757 
33766  bool ShowEdgeVisibilitiesByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, BoolArray & out_validities, BoolArray & out_visibilities) const;
33767 
33774  ShellKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
33775 
33782  ShellKey & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Shell::Component in_apply_to = Shell::Component::Faces);
33783 
33790  ShellKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
33791 
33798  ShellKey & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
33799 
33806  ShellKey & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Shell::Component in_apply_to = Shell::Component::Faces);
33807 
33814  ShellKey & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
33815 
33821  ShellKey & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
33822 
33823 
33830  ShellKey & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const in_rgba_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
33831 
33838  ShellKey & SetVertexRGBAColorsByRange(size_t in_start, RGBAColorArray const & in_rgba_colors, Shell::Component in_apply_to = Shell::Component::Faces);
33839 
33846  ShellKey & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
33847 
33854  ShellKey & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const in_rgba_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
33855 
33862  ShellKey & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColorArray const & in_rgba_colors, Shell::Component in_apply_to = Shell::Component::Faces);
33863 
33870  ShellKey & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
33871 
33877  ShellKey & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
33878 
33879 
33886  ShellKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Shell::Component in_apply_to = Shell::Component::Faces);
33887 
33894  ShellKey & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Shell::Component in_apply_to = Shell::Component::Faces);
33895 
33902  ShellKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
33903 
33910  ShellKey & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Shell::Component in_apply_to = Shell::Component::Faces);
33911 
33918  ShellKey & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Shell::Component in_apply_to = Shell::Component::Faces);
33919 
33926  ShellKey & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
33927 
33933  ShellKey & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
33934 
33935 
33941  ShellKey & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
33942 
33948  ShellKey & SetVertexNormalsByRange(size_t in_start, VectorArray const & in_normals);
33949 
33955  ShellKey & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
33956 
33962  ShellKey & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const in_normals[]);
33963 
33968  ShellKey & SetVertexNormalsByList(SizeTArray const & in_vertices, VectorArray const & in_normals);
33969 
33975  ShellKey & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const & in_normal);
33976 
33981  ShellKey & SetVertexNormalsByList(SizeTArray const & in_vertices, Vector const & in_normal);
33982 
33983 
33991  ShellKey & SetVertexParametersByRange(size_t in_start, size_t in_param_count, float const in_params[], size_t in_param_width=2);
33992 
33999  ShellKey & SetVertexParametersByRange(size_t in_start, FloatArray const & in_params, size_t in_param_width=2);
34000 
34009  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);
34010 
34018  ShellKey & SetVertexParametersByList(SizeTArray const & in_vertices, FloatArray const & in_params, size_t in_param_width=2);
34019 
34020 
34026  ShellKey & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
34027 
34033  ShellKey & SetVertexVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
34034 
34040  ShellKey & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
34041 
34047  ShellKey & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool const in_visibilities[]);
34048 
34053  ShellKey & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray const & in_visibilities);
34054 
34060  ShellKey & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool in_visibility);
34061 
34066  ShellKey & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, bool in_visibility);
34067 
34072  ShellKey & UnsetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[]);
34073 
34078  ShellKey & UnsetVertexColorsByList(size_t in_count, size_t const in_vertices[]);
34079 
34085  ShellKey & UnsetVertexColorsByList(size_t in_count, size_t const in_vertices[], Shell::Component in_apply_to);
34086 
34089  ShellKey & UnsetVertexColors();
34090 
34095  ShellKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
34096 
34100  ShellKey & UnsetVertexColorsByList(SizeTArray const & in_vertices);
34101 
34102 
34106  ShellKey & UnsetVertexColors(Shell::Component in_apply_to);
34107 
34113  ShellKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Shell::Component in_apply_to);
34114 
34119  ShellKey & UnsetVertexColorsByList(SizeTArray const & in_vertices, Shell::Component in_apply_to);
34120 
34121 
34124  ShellKey & UnsetVertexNormals();
34125 
34130  ShellKey & UnsetVertexNormalsByRange(size_t in_start, size_t in_count);
34131 
34135  ShellKey & UnsetVertexNormalsByList(SizeTArray const & in_vertices);
34136 
34137 
34140  ShellKey & UnsetVertexParameters();
34141 
34146  ShellKey & UnsetVertexParametersByRange(size_t in_start, size_t in_count);
34147 
34151  ShellKey & UnsetVertexParametersByList(SizeTArray const & in_vertices);
34152 
34153 
34156  ShellKey & UnsetVertexVisibilities();
34157 
34162  ShellKey & UnsetVertexVisibilitiesByRange(size_t in_start, size_t in_count);
34163 
34167  ShellKey & UnsetVertexVisibilitiesByList(SizeTArray const & in_vertices);
34168 
34169 
34172  ShellKey & UnsetVertexEverything();
34173 
34174 
34186  bool ShowVertexColors(Shell::Component in_apply_to, MaterialTypeArray & out_types,
34187  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
34188 
34202  bool ShowVertexColorsByRange(size_t in_start, size_t in_count, Shell::Component in_apply_to, MaterialTypeArray & out_types,
34203  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
34204 
34219  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Shell::Component in_apply_to, MaterialTypeArray & out_types,
34220  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
34221 
34222 
34229  bool ShowVertexNormals(BoolArray & out_validities, VectorArray & out_normals) const;
34230 
34239  bool ShowVertexNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
34240 
34249  bool ShowVertexNormalsByList(SizeTArray const & in_vertices, BoolArray & out_validities, VectorArray & out_normals) const;
34250 
34258  bool ShowNetVertexNormals(VectorArray & out_normals, Drawing::Handedness in_polygon_handedness = Drawing::Handedness::None) const;
34259 
34269  bool ShowNetVertexNormalsByRange(size_t in_start, size_t in_count, VectorArray & out_normals, Drawing::Handedness in_polygon_handedness = Drawing::Handedness::None) const;
34270 
34278  bool ShowVertexParameters(BoolArray & out_validities, FloatArray & out_params) const;
34279 
34287  bool ShowVertexParameters(BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
34288 
34298  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params) const;
34299 
34309  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
34310 
34320  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params) const;
34321 
34331  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
34332 
34333 
34340  bool ShowVertexVisibilities(BoolArray & out_validities, BoolArray & out_visibilities) const;
34341 
34350  bool ShowVertexVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
34351 
34360  bool ShowVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities) const;
34361 
34362 
34368  ShellKey & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[]);
34369 
34375  ShellKey & SetFaceRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors);
34376 
34382  ShellKey & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color);
34383 
34389  ShellKey & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const in_rgb_colors[]);
34390 
34395  ShellKey & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColorArray const & in_rgb_colors);
34396 
34402  ShellKey & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const & in_rgb_color);
34403 
34408  ShellKey & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColor const & in_rgb_color);
34409 
34410 
34416  ShellKey & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[]);
34417 
34423  ShellKey & SetFaceIndexColorsByRange(size_t in_start, FloatArray const & in_indices);
34424 
34430  ShellKey & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float in_index);
34431 
34437  ShellKey & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float const in_indices[]);
34438 
34443  ShellKey & SetFaceIndexColorsByList(SizeTArray const & in_faces, FloatArray const & in_indices);
34444 
34450  ShellKey & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float in_index);
34451 
34456  ShellKey & SetFaceIndexColorsByList(SizeTArray const & in_faces, float in_index);
34457 
34458 
34464  ShellKey & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
34465 
34471  ShellKey & SetFaceNormalsByRange(size_t in_start, VectorArray const & in_normals);
34472 
34478  ShellKey & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
34479 
34485  ShellKey & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const in_normals[]);
34486 
34491  ShellKey & SetFaceNormalsByList(SizeTArray const & in_faces, VectorArray const & in_normals);
34492 
34498  ShellKey & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const & in_normal);
34499 
34504  ShellKey & SetFaceNormalsByList(SizeTArray const & in_faces, Vector const & in_normal);
34505 
34506 
34512  ShellKey & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
34513 
34519  ShellKey & SetFaceVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
34520 
34526  ShellKey & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
34527 
34533  ShellKey & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool const in_visibilities[]);
34534 
34539  ShellKey & SetFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray const & in_visibilities);
34540 
34546  ShellKey & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool in_visibility);
34547 
34552  ShellKey & SetFaceVisibilitiesByList(SizeTArray const & in_faces, bool in_visibility);
34553 
34554 
34557  ShellKey & UnsetFaceColors();
34558 
34563  ShellKey & UnsetFaceColorsByRange(size_t in_start, size_t in_count);
34564 
34568  ShellKey & UnsetFaceColorsByList(SizeTArray const & in_vertices);
34569 
34574  ShellKey & UnsetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[]);
34575 
34580  ShellKey & UnsetFaceColorsByList(size_t in_count, size_t const in_faces[]);
34581 
34584  ShellKey & UnsetFaceNormals();
34585 
34590  ShellKey & UnsetFaceNormalsByRange(size_t in_start, size_t in_count);
34591 
34595  ShellKey & UnsetFaceNormalsByList(SizeTArray const & in_vertices);
34596 
34597 
34600  ShellKey & UnsetFaceVisibilities();
34601 
34606  ShellKey & UnsetFaceVisibilitiesByRange(size_t in_start, size_t in_count);
34607 
34611  ShellKey & UnsetFaceVisibilitiesByList(SizeTArray const & in_vertices);
34612 
34613 
34616  ShellKey & UnsetFaceEverything();
34617 
34625  bool ShowFaceColors(MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
34626 
34636  bool ShowFaceColorsByRange(size_t in_start, size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
34637 
34648  bool ShowFaceColorsByList(SizeTArray const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
34649 
34656  bool ShowFaceNormals(BoolArray & out_validities, VectorArray & out_normals) const;
34657 
34666  bool ShowFaceNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
34667 
34676  bool ShowFaceNormalsByList(SizeTArray const & in_faces, BoolArray & out_validities, VectorArray & out_normals) const;
34677 
34678 
34684  bool ShowNetFaceNormalsByRange(size_t in_start, size_t in_count, VectorArray & out_normals) const;
34685 
34692  bool ShowNetFaceNormalsByList(SizeTArray const & in_faces, VectorArray & out_normals) const;
34693 
34694 
34701  bool ShowFaceVisibilities(BoolArray & out_validities, BoolArray & out_visibilities) const;
34702 
34711  bool ShowFaceVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
34712 
34721  bool ShowFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities) const;
34722 
34723 
34730  ShellKey & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
34731 
34737  ShellKey & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
34738 
34744  ShellKey & EditPointsByDeletion(size_t in_offset, size_t in_count);
34745 
34751  ShellKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
34752 
34758  ShellKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
34759 
34760 
34767  ShellKey & EditFacelistByInsertion(size_t in_offset, size_t in_count, int const in_facelist[]);
34768 
34774  ShellKey & EditFacelistByInsertion(size_t in_offset, IntArray const & in_facelist);
34775 
34781  ShellKey & EditFacelistByDeletion(size_t in_offset, size_t in_count);
34782 
34791  ShellKey & EditFacelistByReplacement(size_t in_offset, size_t in_count, int const in_facelist[]);
34792 
34800  ShellKey & EditFacelistByReplacement(size_t in_offset, IntArray const & in_facelist);
34801 
34804  void Optimize(ShellOptimizationOptionsKit const & in_shell_optimization_kit);
34805 
34810  void ComputeRelation(PointArray const & in_points, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
34811 
34816  void ComputeRelation(ShellKey const & in_points_source, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
34817 
34822  void ComputeRelation(ShellKit const & in_points_source, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
34823 };
34824 
34825 
34826 
34828 class HPS_API MeshKit : public Kit
34829 {
34830 public:
34832  MeshKit();
34833 
34836  MeshKit(MeshKit const & in_kit);
34837 
34841  MeshKit(MeshKit && in_that);
34842 
34846  MeshKit & operator=(MeshKit && in_that);
34847 
34848  virtual ~MeshKit();
34849 
34850  static const HPS::Type staticType = HPS::Type::MeshKit;
34851  HPS::Type ObjectType() const { return staticType; };
34852 
34855  void Consume(MeshKit & in_kit);
34856 
34859  void Set(MeshKit const & in_kit);
34860 
34863  void Show(MeshKit & out_kit) const;
34864 
34868  MeshKit & operator=(MeshKit const & in_kit);
34869 
34872  bool Empty() const;
34873 
34877  bool Equals(MeshKit const & in_kit) const;
34878 
34882  bool operator==(MeshKit const & in_kit) const;
34883 
34887  bool operator!=(MeshKit const & in_kit) const;
34888 
34891  size_t GetPointCount() const;
34892 
34899  MeshKit & SetPriority(int in_priority);
34900 
34903  MeshKit & UnsetPriority();
34904 
34908  bool ShowPriority(int & out_priority) const;
34909 
34913  MeshKit & SetPoints(PointArray const & in_points);
34914 
34919  MeshKit & SetPoints(size_t in_count, Point const in_points []);
34920 
34926  MeshKit & SetPoints(size_t in_rows, size_t in_columns, HPS::PointArray const & in_points);
34927 
34934  MeshKit & SetPoints(size_t in_rows, size_t in_columns, size_t in_count, Point const in_points []);
34935 
34939  MeshKit & SetRows(size_t in_rows);
34940 
34944  MeshKit & SetColumns(size_t in_columns);
34945 
34948  MeshKit & UnsetPoints();
34949 
34952  MeshKit & UnsetRows();
34953 
34956  MeshKit & UnsetColumns();
34957 
34960  MeshKit & UnsetEverything();
34961 
34965  bool ShowPoints(PointArray & out_points) const;
34966 
34972  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
34973 
34978  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
34979 
34985  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
34986 
34992  bool ShowPoints(size_t & out_rows, size_t & out_columns, PointArray & out_points) const;
34993 
34997  bool ShowRows(size_t & out_rows) const;
34998 
35002  bool ShowColumns(size_t & out_columns) const;
35003 
35009  MeshKit & SetMaterialMapping(MaterialMappingKit const & in_kit);
35010 
35017  MeshKit & SetEdgeVisibilitiesByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], bool const in_visibilities[]);
35018 
35025  MeshKit & SetEdgeVisibilitiesByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], bool in_visibility);
35026 
35032  MeshKit & SetEdgeVisibilitiesByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, bool in_visibility);
35033 
35039  MeshKit & SetEdgeVisibilitiesByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, BoolArray const & in_visibilities);
35040 
35046  MeshKit & SetEdgeIndexColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, FloatArray const & in_indices);
35047 
35053  MeshKit & SetEdgeIndexColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, float in_index);
35054 
35061  MeshKit & SetEdgeIndexColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], float const in_indices[]);
35062 
35069  MeshKit & SetEdgeIndexColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], float in_index);
35070 
35076  MeshKit & SetEdgeRGBColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, RGBColorArray const & in_rgb_colors);
35077 
35083  MeshKit & SetEdgeRGBColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, RGBColor const & in_rgb_color);
35084 
35091  MeshKit & SetEdgeRGBColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], RGBColor const in_rgb_colors[]);
35092 
35099  MeshKit & SetEdgeRGBColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], RGBColor const in_rgb_color);
35100 
35108  bool ShowEdgeColors(SizeTArray & out_vertices1, SizeTArray & out_vertices2, HPS::MaterialTypeArray & out_types, HPS::RGBColorArray & out_rgb_colors, HPS::FloatArray & out_indices);
35109 
35117  bool ShowEdgeColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, HPS::MaterialTypeArray & out_types, HPS::RGBColorArray & out_rgb_colors, HPS::FloatArray & out_indices);
35118 
35126  MeshKit & UnsetEdgeColors();
35127 
35132  MeshKit & UnsetEdgeColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2);
35133 
35139  MeshKit & UnsetEdgeColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[]);
35140 
35143  MeshKit & UnsetEdgeVisibilities();
35144 
35147  MeshKit & UnsetEdgeEverything();
35148 
35153  MeshKit & UnsetEdgeVisibilitiesByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2);
35154 
35160  MeshKit & UnsetEdgeVisibilitiesByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[]);
35161 
35162 
35171  bool ShowEdgeVisibilitiesByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, BoolArray & out_validities, BoolArray & out_visibilities) const;
35172 
35179  MeshKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
35180 
35186  MeshKit & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
35187 
35194  MeshKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
35195 
35202  MeshKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
35203 
35210  MeshKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
35211 
35218  MeshKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
35219 
35225  MeshKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
35226 
35227 
35234  MeshKit & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const in_rgba_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
35235 
35241  MeshKit & SetVertexRGBAColorsByRange(size_t in_start, RGBAColorArray const & in_rgba_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
35242 
35249  MeshKit & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
35250 
35257  MeshKit & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const in_rgba_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
35258 
35265  MeshKit & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColorArray const & in_rgba_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
35266 
35273  MeshKit & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
35274 
35280  MeshKit & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
35281 
35282 
35289  MeshKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Mesh::Component in_apply_to = Mesh::Component::Faces);
35290 
35296  MeshKit & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Mesh::Component in_apply_to = Mesh::Component::Faces);
35297 
35304  MeshKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
35305 
35312  MeshKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Mesh::Component in_apply_to = Mesh::Component::Faces);
35313 
35320  MeshKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Mesh::Component in_apply_to = Mesh::Component::Faces);
35321 
35328  MeshKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
35329 
35335  MeshKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
35336 
35337 
35343  MeshKit & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
35344 
35349  MeshKit & SetVertexNormalsByRange(size_t in_start, VectorArray const & in_normals);
35350 
35356  MeshKit & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
35357 
35363  MeshKit & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const in_normals[]);
35364 
35369  MeshKit & SetVertexNormalsByList(SizeTArray const & in_vertices, VectorArray const & in_normals);
35370 
35376  MeshKit & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const & in_normal);
35377 
35382  MeshKit & SetVertexNormalsByList(SizeTArray const & in_vertices, Vector const & in_normal);
35383 
35384 
35391  MeshKit & SetVertexParametersByRange(size_t in_start, size_t in_param_count, float const in_params[], size_t in_param_width=2);
35392 
35399  MeshKit & SetVertexParametersByRange(size_t in_start, FloatArray const & in_params, size_t in_param_width=2);
35400 
35409  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);
35410 
35418  MeshKit & SetVertexParametersByList(SizeTArray const & in_vertices, FloatArray const & in_params, size_t in_param_width=2);
35419 
35420 
35426  MeshKit & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
35427 
35432  MeshKit & SetVertexVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
35433 
35439  MeshKit & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
35440 
35446  MeshKit & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool const in_visibilities[]);
35447 
35452  MeshKit & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray const & in_visibilities);
35453 
35459  MeshKit & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool in_visibility);
35460 
35465  MeshKit & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, bool in_visibility);
35466 
35467 
35470  MeshKit & UnsetMaterialMapping();
35471 
35474  MeshKit & UnsetVertexColors();
35475 
35480  MeshKit & UnsetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[]);
35481 
35486  MeshKit & UnsetVertexColorsByList(size_t in_count, size_t const in_vertices[]);
35487 
35493  MeshKit & UnsetVertexColorsByList(size_t in_count, size_t const in_vertices[], Mesh::Component in_apply_to);
35494 
35499  MeshKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
35500 
35504  MeshKit & UnsetVertexColorsByList(SizeTArray const & in_vertices);
35505 
35506 
35510  MeshKit & UnsetVertexColors(Mesh::Component in_apply_to);
35511 
35517  MeshKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Mesh::Component in_apply_to);
35518 
35523  MeshKit & UnsetVertexColorsByList(SizeTArray const & in_vertices, Mesh::Component in_apply_to);
35524 
35525 
35528  MeshKit & UnsetVertexNormals();
35529 
35534  MeshKit & UnsetVertexNormalsByRange(size_t in_start, size_t in_count);
35535 
35539  MeshKit & UnsetVertexNormalsByList(SizeTArray const & in_vertices);
35540 
35541 
35544  MeshKit & UnsetVertexParameters();
35545 
35550  MeshKit & UnsetVertexParametersByRange(size_t in_start, size_t in_count);
35551 
35555  MeshKit & UnsetVertexParametersByList(SizeTArray const & in_vertices);
35556 
35557 
35560  MeshKit & UnsetVertexVisibilities();
35561 
35566  MeshKit & UnsetVertexVisibilitiesByRange(size_t in_start, size_t in_count);
35567 
35571  MeshKit & UnsetVertexVisibilitiesByList(SizeTArray const & in_vertices);
35572 
35573 
35576  MeshKit & UnsetVertexEverything();
35577 
35578 
35582  bool ShowMaterialMapping(MaterialMappingKit & out_kit) const;
35583 
35595  bool ShowVertexColors(Mesh::Component in_apply_to, MaterialTypeArray & out_types,
35596  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
35597 
35611  bool ShowVertexColorsByRange(size_t in_start, size_t in_count, Mesh::Component in_apply_to, MaterialTypeArray & out_types,
35612  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
35613 
35628  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Mesh::Component in_apply_to, MaterialTypeArray & out_types,
35629  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
35630 
35631 
35638  bool ShowVertexNormals(BoolArray & out_validities, VectorArray & out_normals) const;
35639 
35648  bool ShowVertexNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
35649 
35658  bool ShowVertexNormalsByList(SizeTArray const & in_vertices, BoolArray & out_validities, VectorArray & out_normals) const;
35659 
35667  bool ShowVertexParameters(BoolArray & out_validities, FloatArray & out_params) const;
35668 
35676  bool ShowVertexParameters(BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
35677 
35687  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params) const;
35688 
35698  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
35699 
35709  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params) const;
35710 
35720  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
35721 
35728  bool ShowVertexVisibilities(BoolArray & out_validities, BoolArray & out_visibilities) const;
35729 
35738  bool ShowVertexVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
35739 
35748  bool ShowVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities) const;
35749 
35750 
35756  MeshKit & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[]);
35757 
35762  MeshKit & SetFaceRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors);
35763 
35769  MeshKit & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color);
35770 
35776  MeshKit & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const in_rgb_colors[]);
35777 
35782  MeshKit & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColorArray const & in_rgb_colors);
35783 
35789  MeshKit & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const & in_rgb_color);
35790 
35795  MeshKit & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColor const & in_rgb_color);
35796 
35797 
35803  MeshKit & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[]);
35804 
35809  MeshKit & SetFaceIndexColorsByRange(size_t in_start, FloatArray const & in_indices);
35810 
35816  MeshKit & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float in_index);
35817 
35823  MeshKit & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float const in_indices[]);
35824 
35829  MeshKit & SetFaceIndexColorsByList(SizeTArray const & in_faces, FloatArray const & in_indices);
35830 
35836  MeshKit & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float in_index);
35837 
35842  MeshKit & SetFaceIndexColorsByList(SizeTArray const & in_faces, float in_index);
35843 
35844 
35850  MeshKit & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
35851 
35856  MeshKit & SetFaceNormalsByRange(size_t in_start, VectorArray const & in_normals);
35857 
35863  MeshKit & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
35864 
35870  MeshKit & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const in_normals[]);
35871 
35876  MeshKit & SetFaceNormalsByList(SizeTArray const & in_faces, VectorArray const & in_normals);
35877 
35883  MeshKit & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const & in_normal);
35884 
35889  MeshKit & SetFaceNormalsByList(SizeTArray const & in_faces, Vector const & in_normal);
35890 
35891 
35897  MeshKit & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
35898 
35903  MeshKit & SetFaceVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
35904 
35910  MeshKit & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
35911 
35917  MeshKit & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool const in_visibilities[]);
35918 
35923  MeshKit & SetFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray const & in_visibilities);
35924 
35930  MeshKit & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool in_visibility);
35931 
35936  MeshKit & SetFaceVisibilitiesByList(SizeTArray const & in_faces, bool in_visibility);
35937 
35938 
35941  MeshKit & UnsetFaceColors();
35942 
35947  MeshKit & UnsetFaceColorsByRange(size_t in_start, size_t in_count);
35948 
35952  MeshKit & UnsetFaceColorsByList(SizeTArray const & in_vertices);
35953 
35958  MeshKit & UnsetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[]);
35959 
35964  MeshKit & UnsetFaceColorsByList(size_t in_count, size_t const in_faces[]);
35965 
35968  MeshKit & UnsetFaceNormals();
35969 
35974  MeshKit & UnsetFaceNormalsByRange(size_t in_start, size_t in_count);
35975 
35979  MeshKit & UnsetFaceNormalsByList(SizeTArray const & in_vertices);
35980 
35981 
35984  MeshKit & UnsetFaceVisibilities();
35985 
35990  MeshKit & UnsetFaceVisibilitiesByRange(size_t in_start, size_t in_count);
35991 
35995  MeshKit & UnsetFaceVisibilitiesByList(SizeTArray const & in_vertices);
35996 
35997 
36000  MeshKit & UnsetFaceEverything();
36001 
36009  bool ShowFaceColors(MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
36010 
36020  bool ShowFaceColorsByRange(size_t in_start, size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
36021 
36032  bool ShowFaceColorsByList(SizeTArray const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
36033 
36034 
36041  bool ShowFaceNormals(BoolArray & out_validities, VectorArray & out_normals) const;
36042 
36051  bool ShowFaceNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
36052 
36061  bool ShowFaceNormalsByList(SizeTArray const & in_faces, BoolArray & out_validities, VectorArray & out_normals) const;
36062 
36069  bool ShowFaceVisibilities(BoolArray & out_validities, BoolArray & out_visibilities) const;
36070 
36079  bool ShowFaceVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
36080 
36089  bool ShowFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities) const;
36090 
36096  MeshKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
36097 
36102  MeshKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
36103 
36108  MeshKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
36109 
36113  MeshKit & UnsetUserData(intptr_t in_index);
36114 
36119  MeshKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
36120 
36124  MeshKit & UnsetUserData(IntPtrTArray const & in_indices);
36125 
36128  MeshKit & UnsetAllUserData();
36129 
36131  size_t ShowUserDataCount() const;
36132 
36136  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
36137 
36142  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
36143 
36148  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
36149 
36150 };
36151 
36152 
36153 
36155 class HPS_API MeshKey : public GeometryKey
36156 {
36157 public:
36159  MeshKey();
36160 
36165  explicit MeshKey(Key const & in_that);
36166 
36169  MeshKey(MeshKey const & in_that);
36170 
36174  MeshKey & operator=(MeshKey const & in_that);
36175 
36179  MeshKey(MeshKey && in_that);
36180 
36184  MeshKey & operator=(MeshKey && in_that);
36185 
36186  ~MeshKey();
36187 
36188  static const HPS::Type staticType = HPS::Type::MeshKey;
36189  HPS::Type ObjectType() const { return staticType; };
36190 
36193  void Consume(MeshKit & in_kit);
36194 
36197  void Set(MeshKit const & in_kit);
36198 
36201  void Show(MeshKit & out_kit) const;
36202 
36205  size_t GetPointCount() const;
36206 
36212  MeshKey & SetPoints(size_t in_rows, size_t in_columns, PointArray const & in_points);
36213 
36220  MeshKey & SetPoints(size_t in_rows, size_t in_columns, size_t in_count, Point const in_points []);
36221 
36225  bool ShowPoints(PointArray & out_points) const;
36226 
36232  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
36233 
36238  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
36239 
36245  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
36246 
36252  bool ShowPoints(size_t & out_rows, size_t & out_columns, PointArray & out_points) const;
36253 
36257  bool ShowRows(size_t & out_rows) const;
36258 
36262  bool ShowColumns(size_t & out_columns) const;
36263 
36264 
36269  MeshKey & SetMaterialMapping(MaterialMappingKit const & in_kit);
36270 
36273  MeshKey & UnsetMaterialMapping();
36274 
36278  bool ShowMaterialMapping(MaterialMappingKit & out_kit) const;
36279 
36286  MeshKey & SetEdgeVisibilitiesByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], bool const in_visibilities[]);
36287 
36294  MeshKey & SetEdgeVisibilitiesByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], bool in_visibility);
36295 
36301  MeshKey & SetEdgeVisibilitiesByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, bool in_visibility);
36302 
36308  MeshKey & SetEdgeVisibilitiesByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, BoolArray const & in_visibilities);
36309 
36315  MeshKey & SetEdgeIndexColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, FloatArray const & in_indices);
36316 
36322  MeshKey & SetEdgeIndexColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, float in_index);
36323 
36330  MeshKey & SetEdgeIndexColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], float const in_indices[]);
36331 
36338  MeshKey & SetEdgeIndexColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], float in_index);
36339 
36345  MeshKey & SetEdgeRGBColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, RGBColorArray const & in_rgb_colors);
36346 
36352  MeshKey & SetEdgeRGBColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, RGBColor const & in_rgb_color);
36353 
36360  MeshKey & SetEdgeRGBColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], RGBColor const in_rgb_colors[]);
36361 
36368  MeshKey & SetEdgeRGBColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], RGBColor const in_rgb_color);
36369 
36377  bool ShowEdgeColors(SizeTArray & out_vertices1, SizeTArray & out_vertices2, HPS::MaterialTypeArray & out_types, HPS::RGBColorArray & out_rgb_colors, HPS::FloatArray & out_indices);
36378 
36386  bool ShowEdgeColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, HPS::MaterialTypeArray & out_types, HPS::RGBColorArray & out_rgb_colors, HPS::FloatArray & out_indices);
36387 
36395  MeshKey & UnsetEdgeColors();
36396 
36401  MeshKey & UnsetEdgeColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2);
36402 
36408  MeshKey & UnsetEdgeColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[]);
36409 
36412  MeshKey & UnsetEdgeVisibilities();
36413 
36416  MeshKey & UnsetEdgeEverything();
36417 
36422  MeshKey & UnsetEdgeVisibilitiesByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2);
36423 
36429  MeshKey & UnsetEdgeVisibilitiesByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[]);
36430 
36431 
36440  bool ShowEdgeVisibilitiesByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, BoolArray & out_validities, BoolArray & out_visibilities) const;
36441 
36448  MeshKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
36449 
36456  MeshKey & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
36457 
36464  MeshKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
36465 
36472  MeshKey & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
36473 
36480  MeshKey & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
36481 
36488  MeshKey & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
36489 
36495  MeshKey & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
36496 
36497 
36504  MeshKey & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const in_rgba_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
36505 
36512  MeshKey & SetVertexRGBAColorsByRange(size_t in_start, RGBAColorArray const & in_rgba_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
36513 
36520  MeshKey & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
36521 
36528  MeshKey & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const in_rgba_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
36529 
36536  MeshKey & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColorArray const & in_rgba_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
36537 
36544  MeshKey & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
36545 
36551  MeshKey & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
36552 
36553 
36560  MeshKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Mesh::Component in_apply_to = Mesh::Component::Faces);
36561 
36568  MeshKey & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Mesh::Component in_apply_to = Mesh::Component::Faces);
36569 
36576  MeshKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
36577 
36584  MeshKey & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Mesh::Component in_apply_to = Mesh::Component::Faces);
36585 
36592  MeshKey & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Mesh::Component in_apply_to = Mesh::Component::Faces);
36593 
36600  MeshKey & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
36601 
36607  MeshKey & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
36608 
36614  MeshKey & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
36615 
36621  MeshKey & SetVertexNormalsByRange(size_t in_start, VectorArray const & in_normals);
36622 
36628  MeshKey & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
36629 
36635  MeshKey & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const in_normals[]);
36636 
36641  MeshKey & SetVertexNormalsByList(SizeTArray const & in_vertices, VectorArray const & in_normals);
36642 
36648  MeshKey & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const & in_normal);
36649 
36654  MeshKey & SetVertexNormalsByList(SizeTArray const & in_vertices, Vector const & in_normal);
36655 
36656 
36664  MeshKey & SetVertexParametersByRange(size_t in_start, size_t in_param_count, float const in_params[], size_t in_param_width=2);
36665 
36672  MeshKey & SetVertexParametersByRange(size_t in_start, FloatArray const & in_params, size_t in_param_width=2);
36673 
36682  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);
36683 
36691  MeshKey & SetVertexParametersByList(SizeTArray const & in_vertices, FloatArray const & in_params, size_t in_param_width=2);
36692 
36693 
36699  MeshKey & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
36700 
36706  MeshKey & SetVertexVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
36707 
36713  MeshKey & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
36714 
36720  MeshKey & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool const in_visibilities[]);
36721 
36726  MeshKey & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray const & in_visibilities);
36727 
36733  MeshKey & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool in_visibility);
36734 
36739  MeshKey & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, bool in_visibility);
36740 
36741 
36744  MeshKey & UnsetVertexColors();
36745 
36750  MeshKey & UnsetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[]);
36751 
36756  MeshKey & UnsetVertexColorsByList(size_t in_count, size_t const in_vertices[]);
36757 
36763  MeshKey & UnsetVertexColorsByList(size_t in_count, size_t const in_vertices[], Mesh::Component in_apply_to);
36764 
36769  MeshKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
36770 
36774  MeshKey & UnsetVertexColorsByList(SizeTArray const & in_vertices);
36775 
36776 
36780  MeshKey & UnsetVertexColors(Mesh::Component in_apply_to);
36781 
36787  MeshKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Mesh::Component in_apply_to);
36788 
36793  MeshKey & UnsetVertexColorsByList(SizeTArray const & in_vertices, Mesh::Component in_apply_to);
36794 
36795 
36798  MeshKey & UnsetVertexNormals();
36799 
36804  MeshKey & UnsetVertexNormalsByRange(size_t in_start, size_t in_count);
36805 
36809  MeshKey & UnsetVertexNormalsByList(SizeTArray const & in_vertices);
36810 
36811 
36814  MeshKey & UnsetVertexParameters();
36815 
36820  MeshKey & UnsetVertexParametersByRange(size_t in_start, size_t in_count);
36821 
36825  MeshKey & UnsetVertexParametersByList(SizeTArray const & in_vertices);
36826 
36827 
36830  MeshKey & UnsetVertexVisibilities();
36831 
36836  MeshKey & UnsetVertexVisibilitiesByRange(size_t in_start, size_t in_count);
36837 
36841  MeshKey & UnsetVertexVisibilitiesByList(SizeTArray const & in_vertices);
36842 
36843 
36846  MeshKey & UnsetVertexEverything();
36847 
36850  MeshKey & UnsetEverything();
36851 
36852 
36864  bool ShowVertexColors(Mesh::Component in_apply_to, MaterialTypeArray & out_types,
36865  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
36866 
36880  bool ShowVertexColorsByRange(size_t in_start, size_t in_count, Mesh::Component in_apply_to, MaterialTypeArray & out_types,
36881  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
36882 
36897  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Mesh::Component in_apply_to, MaterialTypeArray & out_types,
36898  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
36899 
36900 
36907  bool ShowVertexNormals(BoolArray & out_validities, VectorArray & out_normals) const;
36908 
36917  bool ShowVertexNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
36918 
36927  bool ShowVertexNormalsByList(SizeTArray const & in_vertices, BoolArray & out_validities, VectorArray & out_normals) const;
36928 
36936  bool ShowNetVertexNormals(VectorArray & out_normals, Drawing::Handedness in_polygon_handedness = Drawing::Handedness::None) const;
36937 
36947  bool ShowNetVertexNormalsByRange(size_t in_start, size_t in_count, VectorArray & out_normals, Drawing::Handedness in_polygon_handedness = Drawing::Handedness::None) const;
36948 
36956  bool ShowVertexParameters(BoolArray & out_validities, FloatArray & out_params) const;
36957 
36965  bool ShowVertexParameters(BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
36966 
36976  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params) const;
36977 
36987  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
36988 
36998  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params) const;
36999 
37009  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
37010 
37011 
37018  bool ShowVertexVisibilities(BoolArray & out_validities, BoolArray & out_visibilities) const;
37019 
37028  bool ShowVertexVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
37029 
37038  bool ShowVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities) const;
37039 
37040 
37046  MeshKey & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[]);
37047 
37053  MeshKey & SetFaceRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors);
37054 
37060  MeshKey & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color);
37061 
37067  MeshKey & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const in_rgb_colors[]);
37068 
37073  MeshKey & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColorArray const & in_rgb_colors);
37074 
37080  MeshKey & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const & in_rgb_color);
37081 
37086  MeshKey & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColor const & in_rgb_color);
37087 
37088 
37094  MeshKey & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[]);
37095 
37101  MeshKey & SetFaceIndexColorsByRange(size_t in_start, FloatArray const & in_indices);
37102 
37108  MeshKey & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float in_index);
37109 
37115  MeshKey & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float const in_indices[]);
37116 
37121  MeshKey & SetFaceIndexColorsByList(SizeTArray const & in_faces, FloatArray const & in_indices);
37122 
37128  MeshKey & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float in_index);
37129 
37134  MeshKey & SetFaceIndexColorsByList(SizeTArray const & in_faces, float in_index);
37135 
37136 
37142  MeshKey & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
37143 
37149  MeshKey & SetFaceNormalsByRange(size_t in_start, VectorArray const & in_normals);
37150 
37156  MeshKey & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
37157 
37163  MeshKey & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const in_normals[]);
37164 
37169  MeshKey & SetFaceNormalsByList(SizeTArray const & in_faces, VectorArray const & in_normals);
37170 
37176  MeshKey & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const & in_normal);
37177 
37182  MeshKey & SetFaceNormalsByList(SizeTArray const & in_faces, Vector const & in_normal);
37183 
37184 
37190  MeshKey & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
37191 
37197  MeshKey & SetFaceVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
37198 
37204  MeshKey & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
37205 
37211  MeshKey & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool const in_visibilities[]);
37212 
37217  MeshKey & SetFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray const & in_visibilities);
37218 
37224  MeshKey & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool in_visibility);
37225 
37230  MeshKey & SetFaceVisibilitiesByList(SizeTArray const & in_faces, bool in_visibility);
37231 
37232 
37235  MeshKey & UnsetFaceColors();
37236 
37241  MeshKey & UnsetFaceColorsByRange(size_t in_start, size_t in_count);
37242 
37246  MeshKey & UnsetFaceColorsByList(SizeTArray const & in_faces);
37247 
37252  MeshKey & UnsetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[]);
37253 
37258  MeshKey & UnsetFaceColorsByList(size_t in_count, size_t const in_faces[]);
37259 
37262  MeshKey & UnsetFaceNormals();
37263 
37268  MeshKey & UnsetFaceNormalsByRange(size_t in_start, size_t in_count);
37269 
37273  MeshKey & UnsetFaceNormalsByList(SizeTArray const & in_faces);
37274 
37275 
37278  MeshKey & UnsetFaceVisibilities();
37279 
37284  MeshKey & UnsetFaceVisibilitiesByRange(size_t in_start, size_t in_count);
37285 
37289  MeshKey & UnsetFaceVisibilitiesByList(SizeTArray const & in_faces);
37290 
37291 
37294  MeshKey & UnsetFaceEverything();
37295 
37303  bool ShowFaceColors(MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
37304 
37314  bool ShowFaceColorsByRange(size_t in_start, size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
37315 
37326  bool ShowFaceColorsByList(SizeTArray const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
37327 
37334  bool ShowFaceNormals(BoolArray & out_validities, VectorArray & out_normals) const;
37335 
37344  bool ShowFaceNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
37345 
37354  bool ShowFaceNormalsByList(SizeTArray const & in_faces, BoolArray & out_validities, VectorArray & out_normals) const;
37355 
37362  bool ShowFaceVisibilities(BoolArray & out_validities, BoolArray & out_visibilities) const;
37363 
37372  bool ShowFaceVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
37373 
37382  bool ShowFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities) const;
37383 
37392  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[]);
37393 
37401  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);
37402 };
37403 
37404 
37405 
37406 
37408 class HPS_API PolygonKit : public Kit
37409 {
37410 public:
37412  PolygonKit();
37413 
37416  PolygonKit(PolygonKit const & in_kit);
37417 
37421  PolygonKit(PolygonKit && in_that);
37422 
37426  PolygonKit & operator=(PolygonKit && in_that);
37427 
37428  virtual ~PolygonKit();
37429 
37430  static const HPS::Type staticType = HPS::Type::PolygonKit;
37431  HPS::Type ObjectType() const { return staticType; };
37432 
37435  void Consume(PolygonKit & in_kit);
37436 
37439  void Set(PolygonKit const & in_kit);
37440 
37443  void Show(PolygonKit & out_kit) const;
37444 
37448  PolygonKit & operator=(PolygonKit const & in_kit);
37449 
37452  bool Empty() const;
37453 
37457  bool Equals(PolygonKit const & in_kit) const;
37458 
37462  bool operator==(PolygonKit const & in_kit) const;
37463 
37467  bool operator!=(PolygonKit const & in_kit) const;
37468 
37471  size_t GetPointCount() const;
37472 
37479  PolygonKit & SetPriority(int in_priority);
37480 
37483  PolygonKit & UnsetPriority();
37484 
37488  bool ShowPriority(int & out_priority) const;
37489 
37490 
37494  PolygonKit & SetPoints(PointArray const & in_points);
37495 
37500  PolygonKit & SetPoints(size_t in_count, Point const in_points []);
37501 
37504  PolygonKit & UnsetPoints();
37505 
37508  PolygonKit & UnsetEverything();
37509 
37513  bool ShowPoints(PointArray & out_points) const;
37514 
37520  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
37521 
37526  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
37527 
37533  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
37534 
37540  PolygonKit & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
37541 
37546  PolygonKit & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
37547 
37552  PolygonKit & EditPointsByDeletion(size_t in_offset, size_t in_count);
37553 
37559  PolygonKit & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
37560 
37565  PolygonKit & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
37566 
37572  PolygonKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
37573 
37578  PolygonKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
37579 
37584  PolygonKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
37585 
37589  PolygonKit & UnsetUserData(intptr_t in_index);
37590 
37595  PolygonKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
37596 
37600  PolygonKit & UnsetUserData(IntPtrTArray const & in_indices);
37601 
37604  PolygonKit & UnsetAllUserData();
37605 
37607  size_t ShowUserDataCount() const;
37608 
37612  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
37613 
37618  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
37619 
37624  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
37625 };
37626 
37627 
37629 class HPS_API PolygonKey : public GeometryKey
37630 {
37631 public:
37633  PolygonKey();
37634 
37639  explicit PolygonKey(Key const & in_that);
37640 
37643  PolygonKey(PolygonKey const & in_that);
37644 
37648  PolygonKey & operator=(PolygonKey const & in_that);
37649 
37653  PolygonKey(PolygonKey && in_that);
37654 
37658  PolygonKey & operator=(PolygonKey && in_that);
37659 
37660  ~PolygonKey();
37661 
37662  static const HPS::Type staticType = HPS::Type::PolygonKey;
37663  HPS::Type ObjectType() const { return staticType; };
37664 
37665 
37668  void Consume(PolygonKit & in_kit);
37669 
37672  void Set(PolygonKit const & in_kit);
37673 
37676  void Show(PolygonKit & out_kit) const;
37677 
37680  size_t GetPointCount() const;
37681 
37685  PolygonKey & SetPoints(PointArray const & in_points);
37686 
37691  PolygonKey & SetPoints(size_t in_count, Point const in_points []);
37692 
37696  bool ShowPoints(PointArray & out_points) const;
37697 
37703  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
37704 
37709  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
37710 
37716  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
37717 
37723  PolygonKey & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
37724 
37729  PolygonKey & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
37730 
37735  PolygonKey & EditPointsByDeletion(size_t in_offset, size_t in_count);
37736 
37742  PolygonKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
37743 
37748  PolygonKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
37749 };
37750 
37751 
37752 
37753 
37755 class HPS_API GridKit : public Kit
37756 {
37757 public:
37759  GridKit();
37760 
37763  GridKit(GridKit const & in_kit);
37764 
37767  GridKit(GridKit && in_that);
37768 
37769  virtual ~GridKit();
37770 
37771  static const HPS::Type staticType = HPS::Type::GridKit;
37772  HPS::Type ObjectType() const { return staticType; };
37773 
37776  void Consume(GridKit & in_kit);
37777 
37780  void Set(GridKit const & in_kit);
37781 
37784  void Show(GridKit & out_kit) const;
37785 
37789  GridKit & operator=(GridKit const & in_kit);
37790 
37794  GridKit & operator=(GridKit && in_that);
37795 
37798  bool Empty() const;
37799 
37803  bool Equals(GridKit const & in_kit) const;
37804 
37808  bool operator==(GridKit const & in_kit) const;
37809 
37813  bool operator!=(GridKit const & in_kit) const;
37814 
37815 
37822  GridKit & SetPriority(int in_priority);
37823 
37827  GridKit & SetType(Grid::Type in_type);
37828 
37832  GridKit & SetOrigin(Point const & in_origin);
37833 
37840  GridKit & SetFirstPoint(Point const & in_first_point);
37841 
37849  GridKit & SetSecondPoint(Point const & in_second_point);
37850 
37864  GridKit & SetFirstCount(int in_first_count);
37865 
37876  GridKit & SetSecondCount(int in_second_count);
37877 
37878 
37881  GridKit & UnsetPriority();
37882 
37885  GridKit & UnsetType();
37886 
37889  GridKit & UnsetOrigin();
37890 
37893  GridKit & UnsetFirstPoint();
37894 
37897  GridKit & UnsetSecondPoint();
37898 
37901  GridKit & UnsetFirstCount();
37902 
37905  GridKit & UnsetSecondCount();
37906 
37909  GridKit & UnsetEverything();
37910 
37911 
37915  bool ShowPriority(int & out_priority) const;
37916 
37920  bool ShowType(Grid::Type & out_type) const;
37921 
37925  bool ShowOrigin(Point & out_origin) const;
37926 
37930  bool ShowFirstPoint(Point & out_first_point) const;
37931 
37935  bool ShowSecondPoint(Point & out_second_point) const;
37936 
37940  bool ShowFirstCount(int & out_first_count) const;
37941 
37945  bool ShowSecondCount(int & out_second_count) const;
37946 
37952  GridKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
37953 
37958  GridKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
37959 
37964  GridKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
37965 
37969  GridKit & UnsetUserData(intptr_t in_index);
37970 
37975  GridKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
37976 
37980  GridKit & UnsetUserData(IntPtrTArray const & in_indices);
37981 
37984  GridKit & UnsetAllUserData();
37985 
37987  size_t ShowUserDataCount() const;
37988 
37992  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
37993 
37998  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
37999 
38004  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
38005 };
38006 
38007 
38009 class HPS_API GridKey : public GeometryKey
38010 {
38011 public:
38013  GridKey();
38014 
38019  explicit GridKey(Key const & in_that);
38020 
38023  GridKey(GridKey const & in_that);
38024 
38027  GridKey(GridKey && in_that);
38028 
38032  GridKey & operator=(GridKey const & in_that);
38033 
38037  GridKey & operator=(GridKey && in_that);
38038 
38039  ~GridKey();
38040 
38041  static const HPS::Type staticType = HPS::Type::GridKey;
38042  HPS::Type ObjectType() const { return staticType; };
38043 
38046  void Consume(GridKit & in_kit);
38047 
38050  void Set(GridKit const & in_kit);
38051 
38054  void Show(GridKit & out_kit) const;
38055 
38056 
38060  GridKey & SetType(Grid::Type in_type);
38061 
38065  GridKey & SetOrigin(Point const & in_origin);
38066 
38073  GridKey & SetFirstPoint(Point const & in_first_point);
38074 
38082  GridKey & SetSecondPoint(Point const & in_second_point);
38083 
38097  GridKey & SetFirstCount(int in_first_count);
38098 
38109  GridKey & SetSecondCount(int in_second_count);
38110 
38111 
38112 
38116  bool ShowType(Grid::Type & out_type) const;
38117 
38121  bool ShowOrigin(Point & out_origin) const;
38122 
38126  bool ShowFirstPoint(Point & out_first_point) const;
38127 
38131  bool ShowSecondPoint(Point & out_second_point) const;
38132 
38136  bool ShowFirstCount(int & out_first_count) const;
38137 
38141  bool ShowSecondCount(int & out_second_count) const;
38142 };
38143 
38144 
38145 
38146 
38148 class HPS_API IncludeKey : public Key
38149 {
38150 public:
38152  IncludeKey();
38153 
38158  explicit IncludeKey(Key const & in_that);
38159 
38162  IncludeKey(IncludeKey const & in_that);
38163 
38167  IncludeKey & operator=(IncludeKey const & in_that);
38168 
38172  IncludeKey(IncludeKey && in_that);
38173 
38177  IncludeKey & operator=(IncludeKey && in_that);
38178 
38179  ~IncludeKey();
38180 
38181 
38182  static const HPS::Type staticType = HPS::Type::IncludeKey;
38183  HPS::Type ObjectType() const { return staticType; };
38184 
38187  SegmentKey GetTarget() const;
38188 
38189 
38194  IncludeKey & SetPriority(int in_priority);
38195 
38203  IncludeKey & SetConditionalExpression(ConditionalExpression const & in_conditional);
38204 
38205 
38208  IncludeKey & UnsetPriority();
38209 
38212  IncludeKey & UnsetConditionalExpression();
38213 
38214 
38218  bool ShowPriority(int & out_priority) const;
38219 
38223  bool ShowConditionalExpression(ConditionalExpression & out_conditional) const;
38224 
38230  IncludeKey & SetFilter(AttributeLock::Type in_type);
38231 
38238  IncludeKey & SetFilter(size_t in_count, AttributeLock::Type const in_types[]);
38239 
38245  IncludeKey & SetFilter(AttributeLockTypeArray const & in_types);
38246 
38252  IncludeKey & UnsetFilter(AttributeLock::Type in_type);
38253 
38260  IncludeKey & UnsetFilter(size_t in_count, AttributeLock::Type const in_types[]);
38261 
38267  IncludeKey & UnsetFilter(AttributeLockTypeArray const & in_types);
38268 
38274  bool ShowFilter(AttributeLockTypeArray & out_types) const;
38275 
38281  bool ShowFilter(HPS::AttributeLock::Type in_type) const;
38282 };
38283 
38284 
38285 
38287 class HPS_API StyleKey : public Key
38288 {
38289 public:
38291  StyleKey();
38292 
38297  explicit StyleKey(Key const & in_that);
38298 
38301  StyleKey(StyleKey const & in_that);
38302 
38306  StyleKey & operator=(StyleKey const & other);
38307 
38311  StyleKey(StyleKey && in_that);
38312 
38316  StyleKey & operator=(StyleKey && in_that);
38317 
38318  ~StyleKey();
38319 
38320  static const HPS::Type staticType = HPS::Type::StyleKey;
38321  HPS::Type ObjectType() const { return staticType; };
38322 
38323 
38329  bool ShowSource(Style::Type & out_type, SegmentKey & out_segment, UTF8 & out_name) const;
38330 
38331 
38339  StyleKey & SetConditionalExpression(ConditionalExpression const & in_conditional);
38340 
38341 
38344  StyleKey & UnsetConditionalExpression();
38345 
38346 
38350  bool ShowConditionalExpression(ConditionalExpression & out_conditional) const;
38351 
38352 
38358  StyleKey & SetFilter(AttributeLock::Type in_type);
38359 
38366  StyleKey & SetFilter(size_t in_count, AttributeLock::Type const in_types[]);
38367 
38373  StyleKey & SetFilter(AttributeLockTypeArray const & in_types);
38374 
38380  StyleKey & UnsetFilter(AttributeLock::Type in_type);
38381 
38388  StyleKey & UnsetFilter(size_t in_count, AttributeLock::Type const in_types[]);
38389 
38395  StyleKey & UnsetFilter(AttributeLockTypeArray const & in_types);
38396 
38402  bool ShowFilter(AttributeLockTypeArray & out_types) const;
38403 
38409  bool ShowFilter(HPS::AttributeLock::Type in_type) const;
38410 };
38411 
38412 
38413 
38415 class HPS_API ReferenceKey : public GeometryKey
38416 {
38417 public:
38419  ReferenceKey();
38420 
38425  explicit ReferenceKey(Key const & in_that);
38426 
38429  ReferenceKey(ReferenceKey const & in_that);
38430 
38434  ReferenceKey & operator=(ReferenceKey const & in_that);
38435 
38439  ReferenceKey(ReferenceKey && in_that);
38440 
38444  ReferenceKey & operator=(ReferenceKey && in_that);
38445 
38446  ~ReferenceKey();
38447 
38448  static const HPS::Type staticType = HPS::Type::ReferenceKey;
38449  HPS::Type ObjectType() const { return staticType; };
38450 
38454  Key GetTarget() const;
38455 
38459  size_t ShowTargets(bool masked=true) const;
38460 
38465  size_t ShowTargets(KeyArray & out_keys, bool masked=true) const;
38466 
38470  size_t ShowGeometryMask() const;
38471 
38476  size_t ShowGeometryMask(SearchTypeArray & out_geometry_types) const;
38477 
38481  ReferenceKey & SetGeometryMask(SearchTypeArray const & in_geometry_types);
38482 
38485  ReferenceKey & UnsetGeometryMask();
38486 
38489  void SetModellingMatrix(MatrixKit const & in_kit);
38490 
38499  ReferenceKey & SetConditionalExpression(ConditionalExpression const & in_conditional);
38500 
38501 
38503  void UnsetModellingMatrix();
38504 
38507  ReferenceKey & UnsetConditionalExpression();
38508 
38509 
38513  bool ShowModellingMatrix(MatrixKit & out_kit) const;
38514 
38518  bool ShowConditionalExpression(ConditionalExpression & out_conditional) const;
38519 
38520 
38523  ModellingMatrixControl GetModellingMatrixControl();
38524 
38527  ModellingMatrixControl const GetModellingMatrixControl() const;
38528 };
38529 
38530 
38531 
38535 class HPS_API StandAloneWindowOptionsKit : public Kit
38536 {
38537 public:
38540 
38544 
38549 
38554 
38555  virtual ~StandAloneWindowOptionsKit();
38556 
38557  static const HPS::Type staticType = HPS::Type::StandAloneWindowOptionsKit;
38558  HPS::Type ObjectType() const { return staticType; };
38559 
38563  static StandAloneWindowOptionsKit GetDefault();
38564 
38567  void Set(StandAloneWindowOptionsKit const & in_kit);
38568 
38571  void Show(StandAloneWindowOptionsKit & out_kit) const;
38572 
38576  StandAloneWindowOptionsKit & operator=(StandAloneWindowOptionsKit const & in_kit);
38577 
38580  bool Empty() const;
38581 
38585  bool Equals(StandAloneWindowOptionsKit const & in_kit) const;
38586 
38590  bool operator==(StandAloneWindowOptionsKit const & in_kit) const;
38591 
38595  bool operator!=(StandAloneWindowOptionsKit const & in_kit) const;
38596 
38600  StandAloneWindowOptionsKit & SetDriver(Window::Driver in_driver);
38601 
38606  StandAloneWindowOptionsKit & SetAntiAliasCapable(bool in_state, unsigned int in_samples = 4);
38607 
38611  StandAloneWindowOptionsKit & SetTitle(char const * in_window_name);
38612 
38617  StandAloneWindowOptionsKit & SetSubscreen(Rectangle const & in_subscreen);
38618 
38622  StandAloneWindowOptionsKit & SetMobility(Window::Mobility in_mobility);
38623 
38627  StandAloneWindowOptionsKit & SetFullScreen(bool in_state);
38628 
38633  StandAloneWindowOptionsKit & SetPreferredGPU(GPU::Preference in_gpu_preference, char const * in_gpu_name = "");
38634 
38637  StandAloneWindowOptionsKit & UnsetDriver();
38638 
38641  StandAloneWindowOptionsKit & UnsetAntiAliasCapable();
38642 
38645  StandAloneWindowOptionsKit & UnsetTitle();
38646 
38649  StandAloneWindowOptionsKit & UnsetSubscreen();
38650 
38653  StandAloneWindowOptionsKit & UnsetMobility();
38654 
38657  StandAloneWindowOptionsKit & UnsetFullScreen();
38658 
38661  StandAloneWindowOptionsKit & UnsetPreferredGPU();
38662 
38665  StandAloneWindowOptionsKit & UnsetEverything();
38666 
38670  bool ShowDriver(Window::Driver & out_driver) const;
38671 
38676  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
38677 
38681  bool ShowTitle(UTF8 & out_window_name) const;
38682 
38686  bool ShowSubscreen(Rectangle & out_subscreen) const;
38687 
38691  bool ShowMobility(Window::Mobility & out_mobility) const;
38692 
38696  bool ShowFullScreen(bool & out_state) const;
38697 
38702  bool ShowPreferredGPU(GPU::Preference & out_gpu_preference, HPS::UTF8 & out_gpu_name) const;
38703 };
38704 
38705 
38706 
38713 {
38714 public:
38718 
38722 
38727 
38732 
38735 
38736  virtual HPS::Type Type() const { return ObjectType(); }
38737 
38738  static const HPS::Type staticType = HPS::Type::StandAloneWindowOptionsControl;
38739  HPS::Type ObjectType() const { return staticType; };
38740 
38745 
38750  StandAloneWindowOptionsControl & SetSubscreen(Rectangle const & in_subscreen);
38751 
38755  StandAloneWindowOptionsControl & SetMobility(Window::Mobility in_mobility);
38756 
38760  StandAloneWindowOptionsControl & SetFullScreen(bool in_state);
38761 
38764  StandAloneWindowOptionsControl & SetFallbackFonts(UTF8Array const & in_fonts);
38765 
38767  StandAloneWindowOptionsControl & UnsetFallbackFonts();
38768 
38771  size_t ShowFallbackFonts(UTF8Array & out_fonts) const;
38772 
38776  bool ShowDriver(Window::Driver & out_driver) const;
38777 
38782  StandAloneWindowOptionsControl & SetAntiAliasCapable(bool in_state, unsigned int in_samples = 4);
38783 
38788  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
38789 
38793  bool ShowTitle(UTF8 & out_window_name) const;
38794 
38798  bool ShowSubscreen(Rectangle & out_subscreen) const;
38799 
38803  bool ShowMobility(Window::Mobility & out_mobility) const;
38804 
38808  bool ShowFullScreen(bool & out_state) const;
38809 
38813  bool ShowWindowHandle(WindowHandle & out_window_handle) const;
38814 private:
38817 };
38818 
38819 
38820 
38824 class HPS_API OffScreenWindowOptionsKit : public Kit
38825 {
38826 public:
38829 
38833 
38838 
38842  OffScreenWindowOptionsKit & operator=(OffScreenWindowOptionsKit && in_that);
38843 
38844  virtual ~OffScreenWindowOptionsKit();
38845 
38846  static const HPS::Type staticType = HPS::Type::OffScreenWindowOptionsKit;
38847  HPS::Type ObjectType() const { return staticType; };
38848 
38852  static OffScreenWindowOptionsKit GetDefault();
38853 
38856  void Set(OffScreenWindowOptionsKit const & in_kit);
38857 
38860  void Show(OffScreenWindowOptionsKit & out_kit) const;
38861 
38865  OffScreenWindowOptionsKit & operator=(OffScreenWindowOptionsKit const & in_kit);
38866 
38869  bool Empty() const;
38870 
38874  bool Equals(OffScreenWindowOptionsKit const & in_kit) const;
38875 
38879  bool operator==(OffScreenWindowOptionsKit const & in_kit) const;
38880 
38884  bool operator!=(OffScreenWindowOptionsKit const & in_kit) const;
38885 
38889  OffScreenWindowOptionsKit & SetDriver(Window::Driver in_driver);
38890 
38895  OffScreenWindowOptionsKit & SetAntiAliasCapable(bool in_state, unsigned int in_samples = 4);
38896 
38901  OffScreenWindowOptionsKit & SetHardwareResident(bool in_state);
38902 
38907  OffScreenWindowOptionsKit & SetNativeFormat(Window::ImageFormat in_format, float in_quality = 1.0f);
38908 
38913  OffScreenWindowOptionsKit & SetOpacity(bool in_state, float in_opacity = 1.0f);
38914 
38918  OffScreenWindowOptionsKit & SetOpacity(float in_opacity);
38919 
38923  OffScreenWindowOptionsKit & SetFramebufferRetention(bool in_retain);
38924 
38929  OffScreenWindowOptionsKit & SetPreferredGPU(GPU::Preference in_gpu_preference, char const * in_gpu_name = "");
38930 
38933  OffScreenWindowOptionsKit & UnsetDriver();
38934 
38937  OffScreenWindowOptionsKit & UnsetAntiAliasCapable();
38938 
38941  OffScreenWindowOptionsKit & UnsetHardwareResident();
38942 
38945  OffScreenWindowOptionsKit & UnsetNativeFormat();
38946 
38949  OffScreenWindowOptionsKit & UnsetOpacity();
38950 
38953  OffScreenWindowOptionsKit & UnsetFramebufferRetention();
38954 
38957  OffScreenWindowOptionsKit & UnsetPreferredGPU();
38958 
38961  OffScreenWindowOptionsKit & UnsetEverything();
38962 
38966  bool ShowDriver(Window::Driver & out_driver) const;
38967 
38972  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
38973 
38977  bool ShowHardwareResident(bool & out_state) const;
38978 
38983  bool ShowNativeFormat(Window::ImageFormat & out_format, float & out_quality) const;
38984 
38989  bool ShowOpacity(bool & out_state, float & out_opacity) const;
38990 
38994  bool ShowFramebufferRetention(bool & out_retain) const;
38995 
39000  bool ShowPreferredGPU(GPU::Preference & out_gpu_preference, HPS::UTF8 & out_gpu_name) const;
39001 };
39002 
39006 class HPS_API ApplicationWindowOptionsKit : public Kit
39007 {
39008 public:
39011 
39015 
39020 
39025 
39026  virtual ~ApplicationWindowOptionsKit();
39027 
39028  static const HPS::Type staticType = HPS::Type::ApplicationWindowOptionsKit;
39029  HPS::Type ObjectType() const { return staticType; };
39030 
39034  static ApplicationWindowOptionsKit GetDefault();
39035 
39038  void Set(ApplicationWindowOptionsKit const & in_kit);
39039 
39042  void Show(ApplicationWindowOptionsKit & out_kit) const;
39043 
39047  ApplicationWindowOptionsKit & operator=(ApplicationWindowOptionsKit const & in_kit);
39048 
39051  bool Empty() const;
39052 
39056  bool Equals(ApplicationWindowOptionsKit const & in_kit) const;
39057 
39061  bool operator==(ApplicationWindowOptionsKit const & in_kit) const;
39062 
39066  bool operator!=(ApplicationWindowOptionsKit const & in_kit) const;
39067 
39071  ApplicationWindowOptionsKit & SetDriver(Window::Driver in_driver);
39072 
39077  ApplicationWindowOptionsKit & SetAntiAliasCapable(bool in_state, unsigned int in_samples = 4);
39078 
39082  ApplicationWindowOptionsKit & SetPlatformData(PlatformData in_platform_data);
39083 
39087  ApplicationWindowOptionsKit & SetFramebufferRetention(bool in_retain);
39088 
39093  ApplicationWindowOptionsKit & SetPreferredGPU(GPU::Preference in_gpu_preference, char const * in_gpu_name = "");
39094 
39097  ApplicationWindowOptionsKit & UnsetDriver();
39098 
39101  ApplicationWindowOptionsKit & UnsetAntiAliasCapable();
39102 
39105  ApplicationWindowOptionsKit & UnsetPlatformData();
39106 
39109  ApplicationWindowOptionsKit & UnsetFramebufferRetention();
39110 
39113  ApplicationWindowOptionsKit & UnsetPreferredGPU();
39114 
39117  ApplicationWindowOptionsKit & UnsetEverything();
39118 
39122  bool ShowDriver(Window::Driver & out_driver) const;
39123 
39128  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
39129 
39133  bool ShowPlatformData(PlatformData & out_platform_data) const;
39134 
39138  bool ShowFramebufferRetention(bool & out_retain) const;
39139 
39144  bool ShowPreferredGPU(GPU::Preference & out_gpu_preference, HPS::UTF8 & out_gpu_name) const;
39145 
39146 };
39147 
39148 
39149 
39152 {
39153 public:
39157 
39161 
39166 
39171 
39174 
39175  virtual HPS::Type Type() const { return ObjectType(); }
39176 
39177  static const HPS::Type staticType = HPS::Type::ApplicationWindowOptionsControl;
39178  HPS::Type ObjectType() const { return staticType; };
39179 
39184 
39187  size_t ShowFallbackFonts(UTF8Array & out_fonts) const;
39188 
39193  ApplicationWindowOptionsControl & SetAntiAliasCapable(bool in_state, unsigned int in_samples = 4);
39194 
39199  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
39200 
39204  bool ShowDriver(Window::Driver & out_driver) const;
39205 
39209  bool ShowWindowHandle(WindowHandle & out_window_handle) const;
39210 
39214  bool ShowPlatformData(PlatformData & out_platform_data) const;
39215 
39219  bool ShowFramebufferRetention(bool & out_retain) const;
39220 
39224  ApplicationWindowOptionsControl & SetWindowHandle(WindowHandle in_window_handle);
39225 
39229  ApplicationWindowOptionsControl & SetPlatformData(PlatformData in_platform_data);
39230 
39233  ApplicationWindowOptionsControl & SetFallbackFonts(UTF8Array const & in_fonts);
39234 
39236  ApplicationWindowOptionsControl & UnsetFallbackFonts();
39237 
39238 private:
39241 };
39242 
39243 
39244 
39249 class HPS_API StandAloneWindowKey : public WindowKey
39250 {
39251 public:
39254 
39259  StandAloneWindowKey(Key const & in_key);
39260 
39263  StandAloneWindowKey(StandAloneWindowKey const & in_that);
39264 
39269 
39273  StandAloneWindowKey & operator=(StandAloneWindowKey && in_that);
39274 
39276 
39277  static const HPS::Type staticType = HPS::Type::StandAloneWindowKey;
39278  HPS::Type ObjectType() const { return staticType; };
39279 
39282  StandAloneWindowOptionsControl const GetWindowOptionsControl() const;
39283 
39286  StandAloneWindowOptionsControl GetWindowOptionsControl();
39287 
39291  bool ShowWindowOptions(StandAloneWindowOptionsKit & out_kit) const;
39292 
39295  Window::UpdateStatus Pause();
39296 };
39297 
39298 
39299 
39301 class HPS_API ApplicationWindowKey : public WindowKey
39302 {
39303 public:
39306 
39311  ApplicationWindowKey(Key const & in_key);
39312 
39315  ApplicationWindowKey(ApplicationWindowKey const & in_that);
39316 
39321 
39325  ApplicationWindowKey & operator=(ApplicationWindowKey && in_that);
39326 
39328 
39329  static const HPS::Type staticType = HPS::Type::ApplicationWindowKey;
39330  HPS::Type ObjectType() const { return staticType; };
39331 
39334  ApplicationWindowOptionsControl const GetWindowOptionsControl() const;
39335 
39338  ApplicationWindowOptionsControl GetWindowOptionsControl();
39339 
39343  bool ShowWindowOptions(ApplicationWindowOptionsKit & out_kit) const;
39344 };
39345 
39349 
39350 
39351 
39353 class HPS_API GlyphElement : public Object
39354 {
39355 public:
39357  GlyphElement();
39358 
39361  GlyphElement(GlyphElement const & in_that);
39362 
39366  GlyphElement(GlyphElement && in_that);
39367 
39371  GlyphElement & operator=(GlyphElement && in_that);
39372 
39373  virtual ~GlyphElement();
39374 
39375  static const HPS::Type staticType = HPS::Type::GlyphElement;
39376  HPS::Type ObjectType() const { return staticType; };
39377 
39380  void Set(GlyphElement const & in_that);
39381 
39385  GlyphElement & operator=(GlyphElement const & in_that);
39386 
39390  bool Equals(GlyphElement const & in_that) const;
39391 
39395  bool operator==(GlyphElement const & in_that) const;
39396 
39400  bool operator!=(GlyphElement const & in_that) const;
39401 
39404  void SetFill(Glyph::Fill in_fill);
39405 
39408  void SetIndexedColor(byte in_index);
39409 
39411  void SetNormalColor();
39412 
39415  void SetExplicitColor(RGBAColor const & in_color);
39416 
39420  bool ShowFill(Glyph::Fill & out_fill) const;
39421 
39427  bool ShowColor(Glyph::ColorSource & out_source, byte & out_index, RGBAColor & out_color) const;
39428 };
39429 
39430 
39432 class HPS_API LineGlyphElement : public GlyphElement
39433 {
39434 public:
39436  LineGlyphElement();
39437 
39442  LineGlyphElement(GlyphElement const & in_that);
39443 
39446  LineGlyphElement(LineGlyphElement const & in_that);
39447 
39450  explicit LineGlyphElement(GlyphPointArray const & in_points);
39451 
39455  LineGlyphElement(size_t in_count, GlyphPoint const in_points[]);
39456 
39460  LineGlyphElement(LineGlyphElement && in_that);
39461 
39465  LineGlyphElement & operator=(LineGlyphElement && in_that);
39466 
39467  ~LineGlyphElement();
39468 
39469  static const HPS::Type staticType = HPS::Type::LineGlyphElement;
39470  HPS::Type ObjectType() const { return staticType; };
39471 
39474  void SetPoints(GlyphPointArray const & in_points);
39475 
39479  void SetPoints(size_t in_count, GlyphPoint const in_points[]);
39480 
39484  bool ShowPoints(GlyphPointArray & out_points) const;
39485 };
39486 
39487 
39489 class HPS_API ImageGlyphElement : public GlyphElement
39490 {
39491 public:
39494 
39499  ImageGlyphElement(GlyphElement const & in_that);
39500 
39503  ImageGlyphElement(ImageGlyphElement const & in_that);
39504 
39509 
39513  ImageGlyphElement & operator=(ImageGlyphElement && in_that);
39514 
39515  ~ImageGlyphElement();
39516 
39517  static const HPS::Type staticType = HPS::Type::ImageGlyphElement;
39518  HPS::Type ObjectType() const { return staticType; };
39519 
39520 
39524  void SetSource(char const * in_name);
39525 
39530  void SetScaling(float in_x_scale, float in_y_scale);
39531 
39536  void SetOffset(float in_x_offset, float in_y_offset);
39537 
39541  void SetRotation(float in_rotation);
39542 
39546  void SetDecimationFilter(bool in_filter);
39547 
39551  void SetInterpolationFilter(bool in_filter);
39552 
39556  void SetFixedScaling(bool in_fixed_scale);
39557 
39561  void SetFixedColoring(bool in_fixed_color);
39562 
39566  bool ShowSource(UTF8 & out_name) const;
39567 
39572  bool ShowScaling(float & out_x_scale, float & out_y_scale) const;
39573 
39578  bool ShowOffset(float & out_x_offset, float & out_y_offset) const;
39579 
39583  bool ShowRotation(float & out_rotation) const;
39584 
39588  bool ShowDecimationFilter(bool & out_filter) const;
39589 
39593  bool ShowInterpolationFilter(bool & out_filter) const;
39594 
39598  bool ShowFixedScaling(bool & out_fixed_scale) const;
39599 
39603  bool ShowFixedColoring(bool & out_fixed_color) const;
39604 
39605 };
39606 
39607 
39609 class HPS_API DotGlyphElement : public GlyphElement
39610 {
39611 public:
39613  DotGlyphElement();
39614 
39619  DotGlyphElement(GlyphElement const & in_that);
39620 
39623  DotGlyphElement(DotGlyphElement const & in_that);
39624 
39627  explicit DotGlyphElement(GlyphPoint const & in_point);
39628 
39632  DotGlyphElement(DotGlyphElement && in_that);
39633 
39637  DotGlyphElement & operator=(DotGlyphElement && in_that);
39638 
39639  ~DotGlyphElement();
39640 
39641  static const HPS::Type staticType = HPS::Type::DotGlyphElement;
39642  HPS::Type ObjectType() const { return staticType; };
39643 
39646  void SetPoint(GlyphPoint const & in_point);
39647 
39651  bool ShowPoint(GlyphPoint & out_point) const;
39652 };
39653 
39654 
39656 class HPS_API EllipseGlyphElement : public GlyphElement
39657 {
39658 public:
39661 
39666  EllipseGlyphElement(GlyphElement const & in_that);
39667 
39670  EllipseGlyphElement(EllipseGlyphElement const & in_that);
39671 
39675  EllipseGlyphElement(GlyphPoint const & in_lower_left, GlyphPoint const & in_upper_right);
39676 
39681 
39685  EllipseGlyphElement & operator=(EllipseGlyphElement && in_that);
39686 
39688 
39689  static const HPS::Type staticType = HPS::Type::EllipseGlyphElement;
39690  HPS::Type ObjectType() const { return staticType; };
39691 
39694  void SetLowerLeft(GlyphPoint const & in_point);
39695 
39698  void SetUpperRight(GlyphPoint const & in_point);
39699 
39703  void SetPoints(GlyphPoint const & in_lower_left, GlyphPoint const & in_upper_right);
39704 
39708  bool ShowLowerLeft(GlyphPoint & out_point) const;
39709 
39713  bool ShowUpperRight(GlyphPoint & out_point) const;
39714 };
39715 
39717 class HPS_API SphereGlyphElement : public GlyphElement
39718 {
39719 public:
39722 
39727  SphereGlyphElement(GlyphElement const & in_that);
39728 
39731  SphereGlyphElement(SphereGlyphElement const & in_that);
39732 
39737 
39741  SphereGlyphElement & operator=(SphereGlyphElement && in_that);
39742 
39743  ~SphereGlyphElement();
39744 
39745  static const HPS::Type staticType = HPS::Type::SphereGlyphElement;
39746  HPS::Type ObjectType() const { return staticType; };
39747 };
39748 
39749 
39752 {
39753 public:
39756 
39761  CircularArcGlyphElement(GlyphElement const & in_that);
39762 
39766 
39771  CircularArcGlyphElement(GlyphPoint const & in_start, GlyphPoint const & in_intermediate, GlyphPoint const & in_end);
39772 
39777 
39781  CircularArcGlyphElement & operator=(CircularArcGlyphElement && in_that);
39782 
39784 
39785  static const HPS::Type staticType = HPS::Type::CircularArcGlyphElement;
39786  HPS::Type ObjectType() const { return staticType; };
39787 
39790  void SetStartPoint(GlyphPoint const & in_point);
39791 
39794  void SetIntermediatePoint(GlyphPoint const & in_point);
39795 
39798  void SetEndPoint(GlyphPoint const & in_point);
39799 
39804  void SetPoints(GlyphPoint const & in_start, GlyphPoint const & in_intermediate, GlyphPoint const & in_end);
39805 
39809  bool ShowStartPoint(GlyphPoint & out_point) const;
39810 
39814  bool ShowIntermediatePoint(GlyphPoint & out_point) const;
39815 
39819  bool ShowEndPoint(GlyphPoint & out_point) const;
39820 };
39821 
39822 
39823 
39826 {
39827 public:
39830 
39835  InfiniteLineGlyphElement(GlyphElement const & in_that);
39836 
39840 
39845  InfiniteLineGlyphElement(GlyphPoint const & in_first, GlyphPoint const & in_second, InfiniteLine::Type in_type = InfiniteLine::Type::Line);
39846 
39851 
39855  InfiniteLineGlyphElement & operator=(InfiniteLineGlyphElement && in_that);
39856 
39858 
39859  static const HPS::Type staticType = HPS::Type::InfiniteLineGlyphElement;
39860  HPS::Type ObjectType() const { return staticType; };
39861 
39864  void SetFirstPoint(GlyphPoint const & in_point);
39865 
39868  void SetSecondPoint(GlyphPoint const & in_point);
39869 
39873  void SetPoints(GlyphPoint const & in_first, GlyphPoint const & in_second);
39874 
39877  void SetInfiniteType(InfiniteLine::Type in_type);
39878 
39882  bool ShowFirstPoint(GlyphPoint & out_point) const;
39883 
39887  bool ShowSecondPoint(GlyphPoint & out_point) const;
39888 
39892  bool ShowInfiniteType(InfiniteLine::Type & out_type) const;
39893 };
39894 
39895 
39896 
39898 class HPS_API GlyphKit : public Kit
39899 {
39900 public:
39902  GlyphKit();
39903 
39906  GlyphKit(GlyphKit const & in_kit);
39907 
39911  GlyphKit(GlyphKit && in_that);
39912 
39916  GlyphKit & operator=(GlyphKit && in_that);
39917 
39918  virtual ~GlyphKit();
39919 
39920  static const HPS::Type staticType = HPS::Type::GlyphKit;
39921  HPS::Type ObjectType() const { return staticType; };
39922 
39926  static HPS::GlyphKit GetDefault(Glyph::Default in_default_glyph);
39927 
39930  void Set(GlyphKit const & in_kit);
39931 
39934  void Show(GlyphKit & out_kit) const;
39935 
39939  GlyphKit & operator=(GlyphKit const & in_kit);
39940 
39943  bool Empty() const;
39944 
39948  bool Equals(GlyphKit const & in_kit) const;
39949 
39953  bool operator==(GlyphKit const & in_kit) const;
39954 
39958  bool operator!=(GlyphKit const & in_kit) const;
39959 
39963  GlyphKit & SetRadius(sbyte in_radius);
39964 
39969  GlyphKit & SetOffset(GlyphPoint const & in_point);
39970 
39975  GlyphKit & SetOrdered(bool in_ordered);
39976 
39980  GlyphKit & SetElements(GlyphElementArray const & in_def);
39981 
39986  GlyphKit & SetElements(size_t in_count, GlyphElement const in_def []);
39987 
39991  GlyphKit & SetElement(GlyphElement const & in_element);
39992 
39995  GlyphKit & UnsetRadius();
39996 
39999  GlyphKit & UnsetOffset();
40000 
40003  GlyphKit & UnsetOrdered();
40004 
40007  GlyphKit & UnsetElements();
40008 
40011  GlyphKit & UnsetEverything();
40012 
40016  bool ShowRadius(sbyte & out_radius) const;
40017 
40021  bool ShowOffset(GlyphPoint & out_point) const;
40022 
40026  bool ShowOrdered(bool & out_ordered) const;
40027 
40031  bool ShowElements(GlyphElementArray & out_def) const;
40032 };
40033 
40037 
40038 
40041 class HPS_API LinePatternOptionsKit : public Kit
40042 {
40043 public:
40046 
40050 
40055 
40059  LinePatternOptionsKit & operator=(LinePatternOptionsKit && in_that);
40060 
40061  virtual ~LinePatternOptionsKit();
40062 
40063  static const HPS::Type staticType = HPS::Type::LinePatternOptionsKit;
40064  HPS::Type ObjectType() const { return staticType; };
40065 
40068  void Set(LinePatternOptionsKit const & in_kit);
40069 
40072  void Show(LinePatternOptionsKit & out_kit) const;
40073 
40077  LinePatternOptionsKit & operator=(LinePatternOptionsKit const & in_kit);
40078 
40081  bool Empty() const;
40082 
40086  bool Equals(LinePatternOptionsKit const & in_kit) const;
40087 
40091  bool operator==(LinePatternOptionsKit const & in_kit) const;
40092 
40096  bool operator!=(LinePatternOptionsKit const & in_kit) const;
40097 
40101  LinePatternOptionsKit & SetStartCap(char const * in_glyph);
40102 
40106  LinePatternOptionsKit & SetStartCap(LinePattern::Cap in_type);
40107 
40111  LinePatternOptionsKit & SetEndCap(char const * in_glyph);
40112 
40116  LinePatternOptionsKit & SetEndCap(LinePattern::Cap in_type);
40117 
40121  LinePatternOptionsKit & SetInnerCap(LinePattern::Cap in_type);
40122 
40126  LinePatternOptionsKit & SetJoin(char const * in_glyph);
40127 
40131  LinePatternOptionsKit & SetJoin(LinePattern::Join in_type);
40132 
40136  LinePatternOptionsKit & UnsetStartCap();
40137 
40141  LinePatternOptionsKit & UnsetEndCap();
40142 
40145  LinePatternOptionsKit & UnsetInnerCap();
40146 
40150  LinePatternOptionsKit & UnsetJoin();
40151 
40154  LinePatternOptionsKit & UnsetEverything();
40155 
40161  bool ShowStartCap(LinePattern::Modifier & out_modifier, UTF8 & out_glyph, LinePattern::Cap & out_type) const;
40162 
40168  bool ShowEndCap(LinePattern::Modifier & out_modifier, UTF8 & out_glyph, LinePattern::Cap & out_type) const;
40169 
40173  bool ShowInnerCap(LinePattern::Cap & out_type) const;
40174 
40180  bool ShowJoin(LinePattern::Modifier & out_modifier, UTF8 & out_glyph, LinePattern::Join & out_type) const;
40181 };
40182 
40185 class HPS_API LinePatternElement : public Object
40186 {
40187 public:
40190 
40193  LinePatternElement(LinePatternElement const & in_that);
40194 
40199 
40203  LinePatternElement & operator=(LinePatternElement && in_that);
40204 
40205  ~LinePatternElement();
40206 
40207  static const HPS::Type staticType = HPS::Type::LinePatternElement;
40208  HPS::Type ObjectType() const { return staticType; };
40209 
40212  void Set(LinePatternElement const & in_that);
40213 
40217  LinePatternElement & operator=(LinePatternElement const & in_that);
40218 
40222  bool Equals(LinePatternElement const & in_that) const;
40223 
40227  bool operator==(LinePatternElement const & in_that) const;
40228 
40232  bool operator!=(LinePatternElement const & in_that) const;
40233 
40237  void SetSize(float in_size, LinePattern::SizeUnits in_units);
40238 
40243  bool ShowSize(float & out_size, LinePattern::SizeUnits & out_units) const;
40244 };
40245 
40248 {
40249 public:
40252 
40258 
40262 
40266  SolidLinePatternElement(float in_size, LinePattern::SizeUnits in_units);
40267 
40272 
40276  SolidLinePatternElement & operator=(SolidLinePatternElement && in_that);
40277 
40279 
40280  static const HPS::Type staticType = HPS::Type::SolidLinePatternElement;
40281  HPS::Type ObjectType() const { return staticType; };
40282 
40286  void SetColor(RGBAColor const & in_color);
40287 
40291  void SetMaterialByIndex(float in_material_index);
40292 
40298  bool ShowColor(Material::Type & out_type, RGBAColor & out_color, float & out_index) const;
40299 };
40300 
40301 
40304 {
40305 public:
40308 
40314 
40318 
40322  BlankLinePatternElement(float in_size, LinePattern::SizeUnits in_units);
40323 
40328 
40332  BlankLinePatternElement & operator=(BlankLinePatternElement && in_that);
40333 
40335 
40336  static const HPS::Type staticType = HPS::Type::BlankLinePatternElement;
40337  HPS::Type ObjectType() const { return staticType; };
40338 };
40339 
40340 
40343 {
40344 public:
40347 
40353 
40357 
40361  GlyphLinePatternElement & operator=(GlyphLinePatternElement const & in_that);
40362 
40367 
40371  GlyphLinePatternElement & operator=(GlyphLinePatternElement && in_that);
40372 
40374 
40375  static const HPS::Type staticType = HPS::Type::GlyphLinePatternElement;
40376  HPS::Type ObjectType() const { return staticType; };
40377 
40380  void SetSource(char const * in_source);
40381 
40385  void SetWeight(float in_weight, LinePattern::SizeUnits in_units);
40386 
40389  void SetInsetBehavior(LinePattern::InsetBehavior in_behavior);
40390 
40393  void SetMirror(bool in_state);
40394 
40397  void SetFixed(bool in_state);
40398 
40401  void SetRotation(float in_degrees);
40402 
40406  bool ShowSource(UTF8 & out_source) const;
40407 
40412  bool ShowWeight(float & out_weight, LinePattern::SizeUnits & out_units) const;
40413 
40417  bool ShowInsetBehavior(LinePattern::InsetBehavior & out_behavior) const;
40418 
40422  bool ShowMirror(bool & out_state) const;
40423 
40427  bool ShowFixed(bool & out_state) const;
40428 
40432  bool ShowRotation(float & out_degrees) const;
40433 };
40434 
40436 class HPS_API LinePatternParallelKit : public Kit
40437 {
40438 public:
40441 
40445 
40450 
40454  LinePatternParallelKit & operator=(LinePatternParallelKit && in_that);
40455 
40456  virtual ~LinePatternParallelKit();
40457 
40458  static const HPS::Type staticType = HPS::Type::LinePatternParallelKit;
40459  HPS::Type ObjectType() const { return staticType; };
40460 
40463  void Set(LinePatternParallelKit const & in_kit);
40464 
40467  void Show(LinePatternParallelKit & out_kit) const;
40468 
40472  LinePatternParallelKit & operator=(LinePatternParallelKit const & in_kit);
40473 
40476  bool Empty() const;
40477 
40481  bool Equals(LinePatternParallelKit const & in_kit) const;
40482 
40486  bool operator==(LinePatternParallelKit const & in_kit) const;
40487 
40491  bool operator!=(LinePatternParallelKit const & in_kit) const;
40492 
40496  LinePatternParallelKit & SetStartCap(GlyphLinePatternElement const & in_start);
40497 
40501  LinePatternParallelKit & SetEndCap(GlyphLinePatternElement const & in_end);
40502 
40506  LinePatternParallelKit & SetJoin(GlyphLinePatternElement const & in_join);
40507 
40511  LinePatternParallelKit & SetBody(LinePatternElementArray const & in_elements);
40512 
40517  LinePatternParallelKit & SetBody(size_t in_count, LinePatternElement const in_elements []);
40518 
40522  LinePatternParallelKit & SetBody(LinePatternElement const & in_element);
40523 
40527  LinePatternParallelKit & SetAbsoluteLength(bool in_state);
40528 
40532  LinePatternParallelKit & SetAbsoluteWeight(bool in_state);
40533 
40537  LinePatternParallelKit & SetJustification(LinePattern::Justification in_type);
40538 
40545  LinePatternParallelKit & SetOffset(float in_offset, LinePattern::SizeUnits in_units, bool in_fixed = false);
40546 
40552  LinePatternParallelKit & SetWeight(float in_weight, LinePattern::SizeUnits in_units, bool in_fixed = false);
40553 
40557  LinePatternParallelKit & SetContinuous(bool in_state);
40558 
40561  LinePatternParallelKit & UnsetStartCap();
40562 
40565  LinePatternParallelKit & UnsetEndCap();
40566 
40569  LinePatternParallelKit & UnsetJoin();
40570 
40573  LinePatternParallelKit & UnsetBody();
40574 
40577  LinePatternParallelKit & UnsetAbsoluteLength();
40578 
40581  LinePatternParallelKit & UnsetAbsoluteWeight();
40582 
40585  LinePatternParallelKit & UnsetJustification();
40586 
40589  LinePatternParallelKit & UnsetOffset();
40590 
40593  LinePatternParallelKit & UnsetWeight();
40594 
40597  LinePatternParallelKit & UnsetContinuous();
40598 
40601  LinePatternParallelKit & UnsetEverything();
40602 
40606  bool ShowStartCap(GlyphLinePatternElement & out_start) const;
40607 
40611  bool ShowEndCap(GlyphLinePatternElement & out_end) const;
40612 
40616  bool ShowJoin(GlyphLinePatternElement & out_join) const;
40617 
40621  bool ShowBody(LinePatternElementArray & out_elements) const;
40622 
40626  bool ShowAbsoluteLength(bool & out_state) const;
40627 
40631  bool ShowAbsoluteWeight(bool & out_state) const;
40632 
40636  bool ShowJustification(LinePattern::Justification & out_type) const;
40637 
40643  bool ShowOffset(float & out_offset, LinePattern::SizeUnits & out_units, bool & out_fixed) const;
40644 
40650  bool ShowWeight(float & out_weight, LinePattern::SizeUnits & out_units, bool & out_fixed) const;
40651 
40655  bool ShowContinuous(bool & out_state) const;
40656 };
40657 
40658 
40660 class HPS_API LinePatternKit : public Kit
40661 {
40662 public:
40664  LinePatternKit();
40665 
40668  LinePatternKit(LinePatternKit const & in_kit);
40669 
40673  LinePatternKit(LinePatternKit && in_that);
40674 
40678  LinePatternKit & operator=(LinePatternKit && in_that);
40679 
40680  virtual ~LinePatternKit();
40681 
40682  static const HPS::Type staticType = HPS::Type::LinePatternKit;
40683  HPS::Type ObjectType() const { return staticType; };
40684 
40688  static HPS::LinePatternKit GetDefault(LinePattern::Default in_default_line_pattern);
40689 
40692  void Set(LinePatternKit const & in_kit);
40693 
40696  void Show(LinePatternKit & out_kit) const;
40697 
40701  LinePatternKit & operator=(LinePatternKit const & in_kit);
40702 
40705  bool Empty() const;
40706 
40710  bool Equals(LinePatternKit const & in_kit) const;
40711 
40715  bool operator==(LinePatternKit const & in_kit) const;
40716 
40720  bool operator!=(LinePatternKit const & in_kit) const;
40721 
40725  LinePatternKit & SetParallels(LinePatternParallelKitArray const & in_parallels);
40726 
40731  LinePatternKit & SetParallels(size_t in_count, LinePatternParallelKit const in_parallels []);
40732 
40736  LinePatternKit & SetParallel(LinePatternParallelKit const & in_parallel);
40737 
40741  LinePatternKit & SetJoin(LinePattern::Join in_type);
40742 
40745  LinePatternKit & UnsetParallels();
40746 
40749  LinePatternKit & UnsetJoin();
40750 
40753  LinePatternKit & UnsetEverything();
40754 
40758  bool ShowParallels(LinePatternParallelKitArray & out_parallels) const;
40759 
40763  bool ShowJoin(LinePattern::Join & out_type) const;
40764 };
40765 
40766 
40770 
40772 class HPS_API ShapeElement : public Object
40773 {
40774 public:
40776  ShapeElement();
40777 
40780  ShapeElement(ShapeElement const & in_that);
40781 
40785  ShapeElement(ShapeElement && in_that);
40786 
40790  ShapeElement & operator=(ShapeElement && in_that);
40791 
40792  virtual ~ShapeElement();
40793 
40794  static const HPS::Type staticType = HPS::Type::ShapeElement;
40795  HPS::Type ObjectType() const { return staticType; };
40796 
40799  void Set(ShapeElement const & in_that);
40800 
40804  ShapeElement & operator=(ShapeElement const & in_that);
40805 
40809  bool Equals(ShapeElement const & in_that) const;
40810 
40814  bool operator==(ShapeElement const & in_that) const;
40815 
40819  bool operator!=(ShapeElement const & in_that) const;
40820 
40825  ShapeElement & SetDisjointed(bool in_state);
40826 
40832  bool ShowDisjointed(bool & out_state) const;
40833 
40837  ShapeElement & SetFill(bool in_state);
40838 
40843  bool ShowFill(bool & out_state) const;
40844 };
40845 
40847 class HPS_API PolygonShapeElement : public ShapeElement
40848 {
40849 public:
40852 
40857  PolygonShapeElement(ShapeElement const & in_that);
40858 
40861  PolygonShapeElement(PolygonShapeElement const & in_that);
40862 
40865  explicit PolygonShapeElement(ShapePointArray const & in_points);
40866 
40870  PolygonShapeElement(size_t in_count, ShapePoint const in_points[]);
40871 
40876 
40880  PolygonShapeElement & operator=(PolygonShapeElement && in_that);
40881 
40883 
40884  static const HPS::Type staticType = HPS::Type::PolygonShapeElement;
40885  HPS::Type ObjectType() const { return staticType; };
40886 
40889  PolygonShapeElement & SetPoints(ShapePointArray const & in_points);
40890 
40894  PolygonShapeElement & SetPoints(size_t in_count, ShapePoint const in_points[]);
40895 
40899  bool ShowPoints(ShapePointArray & out_points) const;
40900 };
40901 
40903 class HPS_API EllipseShapeElement : public ShapeElement
40904 {
40905 public:
40908 
40913  EllipseShapeElement(ShapeElement const & in_that);
40914 
40917  EllipseShapeElement(EllipseShapeElement const & in_that);
40918 
40923  explicit EllipseShapeElement(ShapePoint const & in_center, ShapePoint const & in_major_axis_point, ShapePoint const & in_minor_axis_point);
40924 
40929 
40933  EllipseShapeElement & operator=(EllipseShapeElement && in_that);
40934 
40936 
40937  static const HPS::Type staticType = HPS::Type::EllipseShapeElement;
40938  HPS::Type ObjectType() const { return staticType; };
40939 
40942  EllipseShapeElement & SetCenter(ShapePoint const & in_center);
40943 
40947  bool ShowCenter(ShapePoint & out_center) const;
40948 
40951  EllipseShapeElement & SetMinorAxisPoint(ShapePoint const & in_minor_axis_point);
40952 
40956  bool ShowMinorAxisPoint(ShapePoint & out_minor_axis_point) const;
40957 
40960  EllipseShapeElement & SetMajorAxisPoint(ShapePoint const & in_major_axis_point);
40961 
40965  bool ShowMajorAxisPoint(ShapePoint & out_major_axis_point) const;
40966 };
40967 
40969 class HPS_API CircleShapeElement : public ShapeElement
40970 {
40971 public:
40974 
40979  CircleShapeElement(ShapeElement const & in_that);
40980 
40983  CircleShapeElement(CircleShapeElement const & in_that);
40984 
40988  explicit CircleShapeElement(ShapePoint const & in_center, ShapePoint const & in_radius);
40989 
40994 
40998  CircleShapeElement & operator=(CircleShapeElement && in_that);
40999 
41000  ~CircleShapeElement();
41001 
41002  static const HPS::Type staticType = HPS::Type::CircleShapeElement;
41003  HPS::Type ObjectType() const { return staticType; };
41004 
41007  CircleShapeElement & SetCenter(ShapePoint const & in_center);
41008 
41012  bool ShowCenter(ShapePoint & out_center) const;
41013 
41016  CircleShapeElement & SetRadius(ShapePoint const & in_radius);
41017 
41021  bool ShowRadius(ShapePoint & out_radius) const;
41022 };
41023 
41026 {
41027 public:
41030 
41035  EllipticalArcShapeElement(ShapeElement const & in_that);
41036 
41040 
41047  explicit EllipticalArcShapeElement(ShapePoint const & in_center, ShapePoint const & in_major_axis_point, ShapePoint const & in_minor_axis_point, float in_start = 0.0f, float in_end = 360.0f);
41048 
41053 
41057  EllipticalArcShapeElement & operator=(EllipticalArcShapeElement && in_that);
41058 
41060 
41061  static const HPS::Type staticType = HPS::Type::EllipticalArcShapeElement;
41062  HPS::Type ObjectType() const { return staticType; };
41063 
41066  EllipticalArcShapeElement & SetCenter(ShapePoint const & in_center);
41067 
41071  bool ShowCenter(ShapePoint & out_center) const;
41072 
41075  EllipticalArcShapeElement & SetMinorAxisPoint(ShapePoint const & in_minor_axis_point);
41076 
41080  bool ShowMinorAxisPoint(ShapePoint & out_minor_axis_point) const;
41081 
41084  EllipticalArcShapeElement & SetMajorAxisPoint(ShapePoint const & in_major_axis_point);
41085 
41089  bool ShowMajorAxisPoint(ShapePoint & out_major_axis_point) const;
41090 
41093  EllipticalArcShapeElement & SetStart(float in_start);
41094 
41098  bool ShowStart(float & out_start) const;
41099 
41102  EllipticalArcShapeElement & SetEnd(float in_end);
41103 
41107  bool ShowEnd(float & out_end) const;
41108 };
41109 
41112 {
41113 public:
41116 
41121  CircularArcShapeElement(ShapeElement const & in_that);
41122 
41126 
41131  explicit CircularArcShapeElement(ShapePoint const & in_start_point, ShapePoint const & in_middle_point, ShapePoint const & in_end_point);
41132 
41137 
41141  CircularArcShapeElement & operator=(CircularArcShapeElement && in_that);
41142 
41144 
41145  static const HPS::Type staticType = HPS::Type::CircularArcShapeElement;
41146  HPS::Type ObjectType() const { return staticType; };
41147 
41150  CircularArcShapeElement & SetStartPoint(ShapePoint const & in_start);
41151 
41155  bool ShowStartPoint(ShapePoint & out_start) const;
41156 
41159  CircularArcShapeElement & SetMiddlePoint(ShapePoint const & in_middle);
41160 
41164  bool ShowMiddlePoint(ShapePoint & out_middle) const;
41165 
41168  CircularArcShapeElement & SetEndPoint(ShapePoint const & in_end);
41169 
41173  bool ShowEndPoint(ShapePoint & out_end) const;
41174 };
41175 
41180 {
41181 public:
41184 
41189  LeaderLineClippingElement(ShapeElement const & in_that);
41190 
41194 
41199 
41203  LeaderLineClippingElement & operator=(LeaderLineClippingElement && in_that);
41204 
41206 
41207  static const HPS::Type staticType = HPS::Type::LeaderLineClippingElement;
41208  HPS::Type ObjectType() const { return staticType; };
41209 
41210  bool ShowClipShapeType(HPS::Type& out_type);
41211 
41215  bool ShowShape(PolygonShapeElement& out_shape) const;
41216 
41220  bool ShowShape(EllipseShapeElement& out_shape) const;
41221 
41225  bool ShowShape(EllipticalArcShapeElement& out_shape) const;
41226 
41230  bool ShowShape(CircleShapeElement& out_shape) const;
41231 
41235  bool ShowShape(CircularArcShapeElement& out_shape) const;
41236 
41239  LeaderLineClippingElement & SetShape(const PolygonShapeElement & in_shape);
41240 
41243  LeaderLineClippingElement & SetShape(const EllipseShapeElement& in_shape);
41244 
41247  LeaderLineClippingElement & SetShape(const EllipticalArcShapeElement & in_shape);
41248 
41251  LeaderLineClippingElement & SetShape(const CircleShapeElement & in_shape);
41252 
41255  LeaderLineClippingElement & SetShape(const CircularArcShapeElement & in_shape);
41256 
41258  LeaderLineClippingElement & UnSetShape();
41259 };
41260 
41265 class HPS_API AnchorShapeElement : public ShapeElement
41266 {
41267 public:
41270 
41275  AnchorShapeElement(ShapeElement const & in_that);
41276 
41279  AnchorShapeElement(AnchorShapeElement const & in_that);
41280 
41283  explicit AnchorShapeElement(ShapePoint const & in_anchor_point);
41284 
41289  explicit AnchorShapeElement(ShapePoint const & in_anchor_point, ShapePointArray const & in_intermediate_points, bool in_connection);
41290 
41295 
41299  AnchorShapeElement & operator=(AnchorShapeElement && in_that);
41300 
41301  ~AnchorShapeElement();
41302 
41303  static const HPS::Type staticType = HPS::Type::AnchorShapeElement;
41304  HPS::Type ObjectType() const { return staticType; };
41305 
41308  AnchorShapeElement & SetAnchor(ShapePoint const & in_anchor);
41309 
41313  bool ShowAnchor(ShapePoint & out_anchor) const;
41314 
41317  AnchorShapeElement & SetIntermediatePoints(ShapePointArray const & in_intermediate_points);
41318 
41322  bool ShowIntermediatePoints(ShapePointArray & out_intermediate_points) const;
41323 
41325  AnchorShapeElement & UnsetIntermediatePoints();
41326 
41329  AnchorShapeElement & SetConnection(bool in_connection);
41330 
41334  bool ShowConnection(bool & out_connection) const;
41335 
41337  AnchorShapeElement & UnsetConnection();
41338 };
41339 
41340 
41342 class HPS_API LineShapeElement : public ShapeElement
41343 {
41344 public:
41346  LineShapeElement();
41347 
41352  LineShapeElement(ShapeElement const & in_that);
41353 
41356  LineShapeElement(LineShapeElement const & in_that);
41357 
41360  explicit LineShapeElement(ShapePointArray const & in_points);
41361 
41365  LineShapeElement(size_t in_count, ShapePoint const in_points []);
41366 
41370  LineShapeElement(ShapePoint const & in_start, ShapePoint const & in_end);
41371 
41375  LineShapeElement(LineShapeElement && in_that);
41376 
41380  LineShapeElement & operator=(LineShapeElement && in_that);
41381 
41382  ~LineShapeElement();
41383 
41384  static const HPS::Type staticType = HPS::Type::LineShapeElement;
41385  HPS::Type ObjectType() const { return staticType; };
41386 
41389  LineShapeElement & SetPoints(ShapePointArray const & in_points);
41390 
41394  LineShapeElement & SetPoints(size_t in_count, ShapePoint const in_points []);
41395 
41399  bool ShowPoints(ShapePointArray & out_points) const;
41400 };
41401 
41405 
41406 
41408 class HPS_API Definition : public Object
41409 {
41410 public:
41412  Definition();
41413 
41416  Definition(Definition const & in_that);
41417 
41421  Definition & operator=(Definition const & in_that);
41422 
41426  Definition(Definition && in_that);
41427 
41431  Definition & operator=(Definition && in_that);
41432 
41433  virtual ~Definition();
41434 
41435  static const HPS::Type staticType = HPS::Type::Definition;
41436  HPS::Type ObjectType() const { return staticType; };
41437 
41439  void Undefine();
41440 
41443  PortfolioKey Owner() const;
41444 
41447  UTF8 Name() const;
41448 
41451  virtual void Assign(Definition const & in_that);
41452 
41456  bool Equals(Definition const & in_that) const;
41457 
41461  bool operator==(Definition const & in_that) const;
41462 
41466  bool operator!=(Definition const & in_that) const;
41467 };
41468 
41469 
41472 class HPS_API PortfolioKey : public Key
41473 {
41474 public:
41476  PortfolioKey();
41477 
41482  explicit PortfolioKey(Key const & in_that);
41483 
41486  PortfolioKey(PortfolioKey const & in_that);
41487 
41491  PortfolioKey & operator=(PortfolioKey const & in_that);
41492 
41496  PortfolioKey(PortfolioKey && in_that);
41497 
41501  PortfolioKey & operator=(PortfolioKey && in_that);
41502 
41503  ~PortfolioKey();
41504 
41505  static const HPS::Type staticType = HPS::Type::PortfolioKey;
41506  HPS::Type ObjectType() const { return staticType; };
41507 
41508  // Define
41509 
41516  TextureDefinition DefineTexture(char const * in_name, ImageDefinition const & in_source);
41517 
41525  TextureDefinition DefineTexture(char const * in_name, ImageDefinition const & in_source, TextureOptionsKit const & in_options);
41526 
41527 
41539  CubeMapDefinition DefineCubeMap(char const * in_name, ImageDefinition const & in_negative_z, ImageDefinition const & in_positive_z,
41540  ImageDefinition const & in_negative_x, ImageDefinition const & in_positive_x,
41541  ImageDefinition const & in_negative_y, ImageDefinition const & in_positive_y);
41542 
41555  CubeMapDefinition DefineCubeMap(char const * in_name, ImageDefinition const & in_negative_z, ImageDefinition const & in_positive_z,
41556  ImageDefinition const & in_negative_x, ImageDefinition const & in_positive_x,
41557  ImageDefinition const & in_negative_y, ImageDefinition const & in_positive_y, TextureOptionsKit const & in_options);
41558 
41559 
41565  ImageDefinition DefineImage(char const * in_name, ImageKit const & in_source);
41566 
41567 
41573  NamedStyleDefinition DefineNamedStyle(char const * in_name, SegmentKey const & in_style_source);
41574 
41575 
41581  MaterialPaletteDefinition DefineMaterialPalette(char const * in_name, MaterialKitArray const & in_source);
41582 
41589  MaterialPaletteDefinition DefineMaterialPalette(char const * in_name, size_t in_count, MaterialKit const in_source []);
41590 
41591 
41597  GlyphDefinition DefineGlyph(char const * in_name, GlyphKit const & in_source);
41598 
41599 
41605  LinePatternDefinition DefineLinePattern(char const * in_name, LinePatternKit const & in_source);
41606 
41607 
41613  ShaderDefinition DefineShader(char const * in_name, ShaderKit const & in_source);
41614 
41620  ShapeDefinition DefineShape(char const * in_name, ShapeKit const & in_source);
41621 
41622  // UnDefine
41623 
41627  PortfolioKey & UndefineTexture(char const * in_name);
41628 
41632  PortfolioKey & UndefineCubeMap(char const * in_name);
41633 
41637  PortfolioKey & UndefineImage(char const * in_name);
41638 
41642  PortfolioKey & UndefineNamedStyle(char const * in_name);
41643 
41647  PortfolioKey & UndefineMaterialPalette(char const * in_name);
41648 
41652  PortfolioKey & UndefineGlyph(char const * in_name);
41653 
41657  PortfolioKey & UndefineLinePattern(char const * in_name);
41658 
41662  PortfolioKey & UndefineShader(char const * in_name);
41663 
41667  PortfolioKey & UndefineShape(char const * in_name);
41668 
41669  // Import collections
41675  PortfolioKey & ImportPortfolio(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
41676 
41677 
41683  PortfolioKey & ImportAllTextures(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
41684 
41690  PortfolioKey & ImportAllCubeMaps(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
41691 
41697  PortfolioKey & ImportAllImages(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
41698 
41704  PortfolioKey & ImportAllNamedStyles(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
41705 
41711  PortfolioKey & ImportAllMaterialPalettes(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
41712 
41718  PortfolioKey & ImportAllGlyphs(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
41719 
41725  PortfolioKey & ImportAllLinePatterns(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
41726 
41732  PortfolioKey & ImportAllShaders(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
41733 
41739  PortfolioKey & ImportAllShapes(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
41740 
41741 
41742  // Import individual definitions
41746  TextureDefinition ImportTexture(TextureDefinition const & in_definition);
41747 
41751  CubeMapDefinition ImportCubeMap(CubeMapDefinition const & in_definition);
41752 
41756  ImageDefinition ImportImage(ImageDefinition const & in_definition);
41757 
41761  NamedStyleDefinition ImportNamedStyle(NamedStyleDefinition const & in_definition);
41762 
41766  MaterialPaletteDefinition ImportMaterialPalette(MaterialPaletteDefinition const & in_definition);
41767 
41771  GlyphDefinition ImportGlyph(GlyphDefinition const & in_definition);
41772 
41776  LinePatternDefinition ImportLinePattern(LinePatternDefinition const & in_definition);
41777 
41781  ShaderDefinition ImportShader(ShaderDefinition const & in_definition);
41782 
41786  ShapeDefinition ImportShape(ShapeDefinition const & in_definition);
41787 
41788 
41789  // Show
41791  size_t GetDefinitionCount() const;
41792 
41794  size_t GetTextureDefinitionCount() const;
41795 
41797  size_t GetCubeMapDefinitionCount() const;
41798 
41800  size_t GetImageDefinitionCount() const;
41801 
41803  size_t GetNamedStyleDefinitionCount() const;
41804 
41806  size_t GetMaterialPaletteDefinitionCount() const;
41807 
41809  size_t GetGlyphDefinitionCount() const;
41810 
41812  size_t GetLinePatternDefinitionCount() const;
41813 
41816  size_t GetShaderDefinitionCount() const;
41817 
41819  size_t GetShapeDefinitionCount() const;
41820 
41824  bool ShowTextureDefinition(char const * in_name) const;
41825 
41830  bool ShowTextureDefinition(char const * in_name, TextureDefinition & out_found) const;
41831 
41835  bool ShowAllTextureDefinitions(TextureDefinitionArray & out_definitions) const;
41836 
41840  bool ShowCubeMapDefinition(char const * in_name) const;
41841 
41846  bool ShowCubeMapDefinition(char const * in_name, CubeMapDefinition & out_found) const;
41847 
41851  bool ShowAllCubeMapDefinitions(CubeMapDefinitionArray & out_definitions) const;
41852 
41856  bool ShowImageDefinition(char const * in_name) const;
41857 
41862  bool ShowImageDefinition(char const * in_name, ImageDefinition & out_found) const;
41863 
41867  bool ShowAllImageDefinitions(ImageDefinitionArray & out_definitions) const;
41868 
41872  bool ShowNamedStyleDefinition(char const * in_name) const;
41873 
41878  bool ShowNamedStyleDefinition(char const * in_name, NamedStyleDefinition & out_found) const;
41879 
41883  bool ShowAllNamedStyleDefinitions(NamedStyleDefinitionArray & out_definitions) const;
41884 
41888  bool ShowMaterialPaletteDefinition(char const * in_name) const;
41889 
41894  bool ShowMaterialPaletteDefinition(char const * in_name, MaterialPaletteDefinition & out_found) const;
41895 
41899  bool ShowAllMaterialPaletteDefinitions(MaterialPaletteDefinitionArray & out_definitions) const;
41900 
41904  bool ShowGlyphDefinition(char const * in_name) const;
41905 
41910  bool ShowGlyphDefinition(char const * in_name, GlyphDefinition & out_found) const;
41911 
41915  bool ShowAllGlyphDefinitions(GlyphDefinitionArray & out_definitions) const;
41916 
41920  bool ShowLinePatternDefinition(char const * in_name) const;
41921 
41926  bool ShowLinePatternDefinition(char const * in_name, LinePatternDefinition & out_found) const;
41927 
41931  bool ShowAllLinePatternDefinitions(LinePatternDefinitionArray & out_definitions) const;
41932 
41936  bool ShowShaderDefinition(char const * in_name) const;
41937 
41942  bool ShowShaderDefinition(char const * in_name, ShaderDefinition & out_found) const;
41943 
41947  bool ShowAllShaderDefinitions(ShaderDefinitionArray & out_definitions) const;
41948 
41952  bool ShowShapeDefinition(char const * in_name) const;
41953 
41958  bool ShowShapeDefinition(char const * in_name, ShapeDefinition & out_found) const;
41959 
41963  bool ShowAllShapeDefinitions(ShapeDefinitionArray & out_definitions) const;
41964 
41965 private:
41967  void MoveTo(SegmentKey const & in_new_owner);
41968 
41970  Key CopyTo(SegmentKey const & in_destination) const;
41971 };
41972 
41973 
41974 
41976 class HPS_API GlyphDefinition : public Definition
41977 {
41978 public:
41980  GlyphDefinition();
41981 
41986  GlyphDefinition(Definition const & in_that);
41987 
41990  GlyphDefinition(GlyphDefinition const & in_that);
41991 
41995  GlyphDefinition & operator=(GlyphDefinition const & in_that);
41996 
42000  GlyphDefinition(GlyphDefinition && in_that);
42001 
42005  GlyphDefinition & operator=(GlyphDefinition && in_that);
42006 
42007  ~GlyphDefinition();
42008 
42009  static const HPS::Type staticType = HPS::Type::GlyphDefinition;
42010  HPS::Type ObjectType() const { return staticType; };
42011 
42014  void Set(GlyphKit const & in_kit);
42015 
42018  void Show(GlyphKit & out_kit) const;
42019 };
42020 
42021 
42023 class HPS_API TextureDefinition : public Definition
42024 {
42025 public:
42028 
42033  TextureDefinition(Definition const & in_that);
42034 
42037  TextureDefinition(TextureDefinition const & in_that);
42038 
42042  TextureDefinition & operator=(TextureDefinition const & in_that);
42043 
42048 
42052  TextureDefinition & operator=(TextureDefinition && in_that);
42053 
42054  ~TextureDefinition();
42055 
42056  static const HPS::Type staticType = HPS::Type::TextureDefinition;
42057  HPS::Type ObjectType() const { return staticType; };
42058 
42061  void SetSource(ImageDefinition const & in_source);
42062 
42066  bool ShowSource(ImageDefinition & out_source) const;
42067 
42073  bool ShowSource(UTF8 & out_source) const;
42074 
42077  void SetOptions(TextureOptionsKit const & in_options);
42078 
42081  void ShowOptions(TextureOptionsKit & out_options) const;
42082 
42083 };
42084 
42088 class HPS_API TextureOptionsKit : public Kit
42089 {
42090 public:
42093 
42096  TextureOptionsKit(TextureOptionsKit const & in_kit);
42097 
42102 
42106  TextureOptionsKit & operator=(TextureOptionsKit && in_that);
42107 
42108  virtual ~TextureOptionsKit();
42109 
42110  static const HPS::Type staticType = HPS::Type::TextureOptionsKit;
42111  HPS::Type ObjectType() const { return staticType; };
42112 
42116  static TextureOptionsKit GetDefault();
42117 
42120  void Set(TextureOptionsKit const & in_kit);
42121 
42124  void Show(TextureOptionsKit & out_kit) const;
42125 
42129  TextureOptionsKit & operator=(TextureOptionsKit const & in_kit);
42130 
42133  bool Empty() const;
42134 
42138  bool Equals(TextureOptionsKit const & in_kit) const;
42139 
42143  bool operator==(TextureOptionsKit const & in_kit) const;
42144 
42148  bool operator!=(TextureOptionsKit const & in_kit) const;
42149 
42154  TextureOptionsKit & SetDecal(bool in_state);
42155 
42159  TextureOptionsKit & SetDownSampling(bool in_state);
42160 
42164  TextureOptionsKit & SetModulation(bool in_state);
42165 
42169  TextureOptionsKit & SetParameterOffset(size_t in_offset);
42170 
42174  TextureOptionsKit & SetParameterizationSource(Material::Texture::Parameterization in_source);
42175 
42179  TextureOptionsKit & SetTiling(Material::Texture::Tiling in_tiling);
42180 
42184  TextureOptionsKit & SetInterpolationFilter(Material::Texture::Interpolation in_filter);
42185 
42189  TextureOptionsKit & SetDecimationFilter(Material::Texture::Decimation in_filter);
42190 
42194  TextureOptionsKit & SetTransformMatrix(MatrixKit const & in_transform);
42195 
42200  TextureOptionsKit & SetValueScale(float in_min, float in_max);
42201 
42204  TextureOptionsKit & UnsetDecal();
42205 
42208  TextureOptionsKit & UnsetDownSampling();
42209 
42212  TextureOptionsKit & UnsetModulation();
42213 
42216  TextureOptionsKit & UnsetParameterOffset();
42217 
42220  TextureOptionsKit & UnsetParameterizationSource();
42221 
42224  TextureOptionsKit & UnsetTiling();
42225 
42228  TextureOptionsKit & UnsetInterpolationFilter();
42229 
42232  TextureOptionsKit & UnsetDecimationFilter();
42233 
42236  TextureOptionsKit & UnsetTransformMatrix();
42237 
42240  TextureOptionsKit & UnsetValueScale();
42241 
42244  TextureOptionsKit & UnsetEverything();
42245 
42249  bool ShowDecal(bool & out_state) const;
42250 
42254  bool ShowDownSampling(bool & out_state) const;
42255 
42259  bool ShowModulation(bool & out_state) const;
42260 
42264  bool ShowParameterOffset(size_t & out_offset) const;
42265 
42269  bool ShowParameterizationSource(Material::Texture::Parameterization & out_source) const;
42270 
42274  bool ShowTiling(Material::Texture::Tiling & out_tiling) const;
42275 
42279  bool ShowInterpolationFilter(Material::Texture::Interpolation & out_filter) const;
42280 
42284  bool ShowDecimationFilter(Material::Texture::Decimation & out_filter) const;
42285 
42289  bool ShowTransformMatrix(MatrixKit & out_transform) const;
42290 
42295  bool ShowValueScale(float & out_min, float & out_max) const;
42296 };
42297 
42298 
42300 class HPS_API Image
42301 {
42302 public:
42305  enum class Format : uint32_t
42306  {
42307  RGB,
42308  RGBA,
42309  ARGB,
42310  Mapped8,
42311  Grayscale,
42312  Bmp,
42313  Jpeg,
42314  Png,
42315  Targa,
42316  DXT1,
42317  DXT3,
42318  DXT5
42319  };
42320 
42322 class HPS_API ExportOptionsKit : public Kit
42323  {
42324  public:
42326  ExportOptionsKit();
42327 
42330  ExportOptionsKit(ExportOptionsKit const & in_kit);
42331 
42335  ExportOptionsKit(ExportOptionsKit && in_that);
42336 
42340  ExportOptionsKit & operator=(ExportOptionsKit && in_that);
42341 
42342  virtual ~ExportOptionsKit();
42343 
42344  static const HPS::Type staticType = HPS::Type::ImageExportOptionsKit;
42345  HPS::Type ObjectType() const { return staticType; };
42346 
42350  static ExportOptionsKit GetDefault();
42351 
42354  void Set(ExportOptionsKit const & in_kit);
42355 
42358  void Show(ExportOptionsKit & out_kit) const;
42359 
42363  ExportOptionsKit & operator=(ExportOptionsKit const & in_kit);
42364 
42367  bool Empty() const;
42368 
42372  bool Equals(ExportOptionsKit const & in_kit) const;
42373 
42377  bool operator==(ExportOptionsKit const & in_kit) const;
42378 
42382  bool operator!=(ExportOptionsKit const & in_kit) const;
42383 
42388  ExportOptionsKit & SetSize(unsigned int in_width, unsigned int in_height);
42389 
42394  ExportOptionsKit & SetFormat(Image::Format in_format);
42395 
42400  ExportOptionsKit & SetTransparentBackground(bool in_state);
42401 
42404  ExportOptionsKit & UnsetSize();
42405 
42408  ExportOptionsKit & UnsetFormat();
42409 
42412  ExportOptionsKit & UnsetTransparentBackground();
42413 
42416  ExportOptionsKit & UnsetEverything();
42417 
42422  bool ShowSize(unsigned int & out_width, unsigned int & out_height) const;
42423 
42427  bool ShowFormat(Image::Format & out_format) const;
42428 
42432  bool ShowTransparentBackground(bool & out_state) const;
42433  };
42434 
42436 class HPS_API ImportOptionsKit : public Kit
42437  {
42438  public:
42440  ImportOptionsKit();
42441 
42444  ImportOptionsKit(ImportOptionsKit const & in_kit);
42445 
42449  ImportOptionsKit(ImportOptionsKit && in_that);
42450 
42454  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
42455 
42456  virtual ~ImportOptionsKit();
42457 
42458  static const HPS::Type staticType = HPS::Type::ImageImportOptionsKit;
42459  HPS::Type ObjectType() const { return staticType; };
42460 
42463  void Set(ImportOptionsKit const & in_kit);
42464 
42467  void Show(ImportOptionsKit & out_kit) const;
42468 
42472  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
42473 
42476  bool Empty() const;
42477 
42481  bool Equals(ImportOptionsKit const & in_kit) const;
42482 
42486  bool operator==(ImportOptionsKit const & in_kit) const;
42487 
42491  bool operator!=(ImportOptionsKit const & in_kit) const;
42492 
42499  ImportOptionsKit & SetSize(unsigned int in_width, unsigned int in_height);
42500 
42504  ImportOptionsKit & SetFormat(Image::Format in_format);
42505 
42510  ImportOptionsKit & SetDownSampling(bool in_state);
42511 
42516  ImportOptionsKit & SetCompressionQuality(float in_quality);
42517 
42520  ImportOptionsKit & UnsetSize();
42521 
42524  ImportOptionsKit & UnsetFormat();
42525 
42528  ImportOptionsKit & UnsetDownSampling();
42529 
42532  ImportOptionsKit & UnsetCompressionQuality();
42533 
42536  ImportOptionsKit & UnsetEverything();
42537 
42542  bool ShowSize(unsigned int & out_width, unsigned int & out_height) const;
42543 
42547  bool ShowFormat(Image::Format & out_format) const;
42548 
42552  bool ShowDownSampling(bool & out_state) const;
42553 
42557  bool ShowCompressionQuality(float & out_quality) const;
42558  };
42559 
42561  class HPS_API File
42562  {
42563  public:
42569  static ImageKit Import(char const * in_file_name, ImportOptionsKit const & in_options);
42570 
42577  static void Export(char const * in_file_name, HPS::WindowKey const & in_window, ExportOptionsKit const & in_options);
42578 
42587  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, bool in_transparent_background = false);
42588 
42593  static void Export(char const * in_file_name, HPS::ImageKit const & in_image_kit);
42594 
42595  private:
42597  File();
42598  };
42599 
42600 private:
42602  Image();
42603 };
42604 
42605 
42607 class HPS_API ImageKit : public Kit
42608 {
42609 public:
42611  ImageKit();
42612 
42615  ImageKit(ImageKit const & in_kit);
42616 
42621  ImageKit(ImageKit const & in_kit, HPS::Image::Format in_format);
42622 
42626  ImageKit(ImageKit && in_that);
42627 
42631  ImageKit & operator=(ImageKit && in_that);
42632 
42633  virtual ~ImageKit();
42634 
42635  static const HPS::Type staticType = HPS::Type::ImageKit;
42636  HPS::Type ObjectType() const { return staticType; };
42637 
42640  void Set(ImageKit const & in_kit);
42641 
42644  void Show(ImageKit & out_kit) const;
42645 
42649  ImageKit & operator=(ImageKit const & in_kit);
42650 
42653  bool Empty() const;
42654 
42658  bool Equals(ImageKit const & in_kit) const;
42659 
42663  bool operator==(ImageKit const & in_kit) const;
42664 
42668  bool operator!=(ImageKit const & in_kit) const;
42669 
42673  void Convert(ImageKit const & in_kit, HPS::Image::Format in_format);
42674 
42677  void Convert(HPS::Image::Format in_format);
42678 
42683  ImageKit & SetSize(unsigned int in_width, unsigned int in_height);
42684 
42688  ImageKit & SetData(ByteArray const & in_image_data);
42689 
42694  ImageKit & SetData(size_t in_byte_count, byte const in_image_data []);
42695 
42699  ImageKit & SetFormat(Image::Format in_format);
42700 
42704  ImageKit & SetDownSampling(bool in_state);
42705 
42709  ImageKit & SetCompressionQuality(float in_quality);
42710 
42713  ImageKit & UnsetSize();
42714 
42717  ImageKit & UnsetData();
42718 
42721  ImageKit & UnsetFormat();
42722 
42725  ImageKit & UnsetDownSampling();
42726 
42729  ImageKit & UnsetCompressionQuality();
42730 
42733  ImageKit & UnsetEverything();
42734 
42739  bool ShowSize(unsigned int & out_width, unsigned int & out_height) const;
42740 
42744  bool ShowData(ByteArray & out_image_data) const;
42745 
42749  bool ShowFormat(Image::Format & out_format) const;
42750 
42754  bool ShowDownSampling(bool & out_state) const;
42755 
42759  bool ShowCompressionQuality(float & out_quality) const;
42760 };
42761 
42762 
42768 {
42769 public:
42773 
42778 
42783 
42788 
42790 
42791  virtual HPS::Type Type() const { return ObjectType(); }
42792 
42793  static const HPS::Type staticType = HPS::Type::OffScreenWindowOptionsControl;
42794  HPS::Type ObjectType() const { return staticType; };
42795 
42799  OffScreenWindowOptionsControl & operator=(OffScreenWindowOptionsControl const & in_that);
42800 
42805  OffScreenWindowOptionsControl & SetSize(unsigned int in_width, unsigned int in_height);
42806 
42811  OffScreenWindowOptionsControl & SetNativeFormat(Window::ImageFormat in_format, float in_quality = 1.0f);
42812 
42815  OffScreenWindowOptionsControl & SetFallbackFonts(UTF8Array const & in_fonts);
42816 
42818  OffScreenWindowOptionsControl & UnsetFallbackFonts();
42819 
42822  size_t ShowFallbackFonts(UTF8Array & out_fonts) const;
42823 
42827  bool ShowDriver(Window::Driver & out_driver) const;
42828 
42833  OffScreenWindowOptionsControl & SetAntiAliasCapable(bool in_state, unsigned int in_samples = 4);
42834 
42839  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
42840 
42845  bool ShowSize(unsigned int & out_width, unsigned int & out_height) const;
42846 
42851  bool ShowImage(Image::Format in_format, ImageKit & out_image) const;
42852 
42857  bool ShowImage(ByteArray & out_bytes) const;
42858 
42862  bool ShowHardwareResident(bool & out_state) const;
42863 
42868  bool ShowOpacity(bool & out_state, float & out_opacity) const;
42869 
42874  bool ShowNativeFormat(Window::ImageFormat & out_format, float & out_quality) const;
42875 
42879  bool ShowFramebufferRetention(bool & out_retain) const;
42880 
42881 
42882 private:
42885 };
42886 
42887 
42890 class HPS_API OffScreenWindowKey : public WindowKey
42891 {
42892 public:
42895 
42900  OffScreenWindowKey(Key const & in_key);
42901 
42904  OffScreenWindowKey(OffScreenWindowKey const & in_that);
42905 
42910 
42914  OffScreenWindowKey & operator=(OffScreenWindowKey && in_that);
42915 
42916  ~OffScreenWindowKey();
42917 
42918  static const HPS::Type staticType = HPS::Type::OffScreenWindowKey;
42919  HPS::Type ObjectType() const { return staticType; };
42920 
42923  OffScreenWindowOptionsControl const GetWindowOptionsControl() const;
42924 
42927  OffScreenWindowOptionsControl GetWindowOptionsControl();
42928 
42932  bool ShowWindowOptions(OffScreenWindowOptionsKit & out_kit) const;
42933 };
42934 
42935 
42936 
42937 
42939 class HPS_API ImageDefinition : public Definition
42940 {
42941 public:
42943  ImageDefinition();
42944 
42949  ImageDefinition(Definition const & in_that);
42950 
42953  ImageDefinition(ImageDefinition const & in_that);
42954 
42958  ImageDefinition & operator=(ImageDefinition const & in_that);
42959 
42963  ImageDefinition(ImageDefinition && in_that);
42964 
42968  ImageDefinition & operator=(ImageDefinition && in_that);
42969 
42970  ~ImageDefinition();
42971 
42972  static const HPS::Type staticType = HPS::Type::ImageDefinition;
42973  HPS::Type ObjectType() const { return staticType; };
42974 
42977  void Set(ImageKit const & in_kit);
42978 
42981  void Show(ImageKit & out_kit) const;
42982 };
42983 
42985 class HPS_API CubeMapDefinition : public Definition
42986 {
42987 public:
42990 
42995  CubeMapDefinition(Definition const & in_that);
42996 
42999  CubeMapDefinition(CubeMapDefinition const & in_that);
43000 
43004  CubeMapDefinition & operator=(CubeMapDefinition const & in_that);
43005 
43010 
43014  CubeMapDefinition & operator=(CubeMapDefinition && in_that);
43015 
43016  ~CubeMapDefinition();
43017 
43018  static const HPS::Type staticType = HPS::Type::CubeMapDefinition;
43019  HPS::Type ObjectType() const { return staticType; };
43020 
43028  void SetSource(ImageDefinition const & in_negative_z, ImageDefinition const & in_positive_z,
43029  ImageDefinition const & in_negative_x, ImageDefinition const & in_positive_x,
43030  ImageDefinition const & in_negative_y, ImageDefinition const & in_positive_y);
43031 
43039  void ShowSource(ImageDefinition & out_negative_z, ImageDefinition & out_positive_z,
43040  ImageDefinition & out_negative_x, ImageDefinition & out_positive_x,
43041  ImageDefinition & out_negative_y, ImageDefinition & out_positive_y) const;
43042 
43046  void ShowSource(ImageDefinitionArray & out_image_sources) const;
43047 
43050  void SetOptions(TextureOptionsKit const & in_options);
43051 
43054  void ShowOptions(TextureOptionsKit & out_options) const;
43055 };
43056 
43057 
43059 class HPS_API NamedStyleDefinition : public Definition
43060 {
43061 public:
43064 
43069  NamedStyleDefinition(Definition const & in_that);
43070 
43073  NamedStyleDefinition(NamedStyleDefinition const & in_that);
43074 
43078  NamedStyleDefinition & operator=(NamedStyleDefinition const & in_that);
43079 
43084 
43088  NamedStyleDefinition & operator=(NamedStyleDefinition && in_that);
43089 
43091 
43092  static const HPS::Type staticType = HPS::Type::NamedStyleDefinition;
43093  HPS::Type ObjectType() const { return staticType; };
43094 
43098  SegmentKey GetSource() const;
43099 };
43100 
43101 
43104 {
43105 public:
43108 
43113  MaterialPaletteDefinition(Definition const & in_that);
43114 
43118 
43122  MaterialPaletteDefinition & operator=(MaterialPaletteDefinition const & in_that);
43123 
43128 
43132  MaterialPaletteDefinition & operator=(MaterialPaletteDefinition && in_that);
43133 
43135 
43136  static const HPS::Type staticType = HPS::Type::MaterialPaletteDefinition;
43137  HPS::Type ObjectType() const { return staticType; };
43138 
43141  void Set(MaterialKitArray const & in_source);
43142 
43146  void Set(size_t in_count, MaterialKit const in_source []);
43147 
43150  void Show(MaterialKitArray & out_source) const;
43151 };
43152 
43153 
43154 
43156 class HPS_API LinePatternDefinition : public Definition
43157 {
43158 public:
43161 
43166  LinePatternDefinition(Definition const & in_that);
43167 
43171 
43175  LinePatternDefinition & operator=(LinePatternDefinition const & in_that);
43176 
43181 
43185  LinePatternDefinition & operator=(LinePatternDefinition && in_that);
43186 
43188 
43189  static const HPS::Type staticType = HPS::Type::LinePatternDefinition;
43190  HPS::Type ObjectType() const { return staticType; };
43191 
43194  void Set(LinePatternKit const & in_kit);
43195 
43198  void Show(LinePatternKit & out_kit) const;
43199 };
43200 
43201 
43202 
43204 class HPS_API Shader
43205 {
43206 public:
43209  enum class Parameterization : uint32_t
43210  {
43212  Cylinder,
43214  PhysicalReflection,
43216  Object,
43222  NaturalUV,
43224  ReflectionVector,
43226  SurfaceNormal,
43228  Sphere,
43230  UV,
43232  World
43233  };
43234 
43236 class HPS_API ImportOptionsKit : public Kit
43237  {
43238  public:
43240  ImportOptionsKit();
43241 
43244  ImportOptionsKit(ImportOptionsKit const & in_kit);
43245 
43249  ImportOptionsKit(ImportOptionsKit && in_that);
43250 
43254  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
43255 
43256  virtual ~ImportOptionsKit();
43257 
43258  static const HPS::Type staticType = HPS::Type::ShaderImportOptionsKit;
43259  HPS::Type ObjectType() const { return staticType; };
43260 
43263  void Set(ImportOptionsKit const & in_kit);
43264 
43267  void Show(ImportOptionsKit & out_kit) const;
43268 
43272  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
43273 
43276  bool Empty() const;
43277 
43281  bool Equals(ImportOptionsKit const & in_kit) const;
43282 
43286  bool operator==(ImportOptionsKit const & in_kit) const;
43287 
43291  bool operator!=(ImportOptionsKit const & in_kit) const;
43292 
43299  ImportOptionsKit & SetMultitexture(bool in_state);
43300 
43304  ImportOptionsKit & SetParameterizationSource(Parameterization in_source);
43305 
43309  ImportOptionsKit & SetTransformMatrix(MatrixKit const & in_transform);
43310 
43314  ImportOptionsKit & UnsetMultitexture();
43315 
43318  ImportOptionsKit & UnsetParameterizationSource();
43319 
43322  ImportOptionsKit & UnsetTransformMatrix();
43323 
43326  ImportOptionsKit & UnsetEverything();
43327 
43333  bool ShowMultitexture(bool & out_state) const;
43334 
43338  bool ShowParameterizationSource(Parameterization & out_source) const;
43339 
43343  bool ShowTransformMatrix(MatrixKit & out_transform) const;
43344  };
43345 
43347  class HPS_API File
43348  {
43349  public:
43355  static ShaderKit Import(char const * in_file_name, ImportOptionsKit const & in_options);
43356 
43357  private:
43359  File();
43360  };
43361 
43362 private:
43364  Shader();
43365 };
43366 
43367 
43369 class HPS_API ShaderKit : public Kit
43370 {
43371 public:
43373  ShaderKit();
43374 
43377  ShaderKit(ShaderKit const & in_kit);
43378 
43382  ShaderKit(ShaderKit && in_that);
43383 
43387  ShaderKit & operator=(ShaderKit && in_that);
43388 
43389  virtual ~ShaderKit();
43390 
43391  static const HPS::Type staticType = HPS::Type::ShaderKit;
43392  HPS::Type ObjectType() const { return staticType; };
43393 
43396  void Set(ShaderKit const & in_kit);
43397 
43400  void Show(ShaderKit & out_kit) const;
43401 
43405  ShaderKit & operator=(ShaderKit const & in_kit);
43406 
43409  bool Empty() const;
43410 
43414  bool Equals(ShaderKit const & in_kit) const;
43415 
43419  bool operator==(ShaderKit const & in_kit) const;
43420 
43424  bool operator!=(ShaderKit const & in_kit) const;
43425 
43429  ShaderKit & SetSource(char const * in_source);
43430 
43437  ShaderKit & SetMultitexture(bool in_state);
43438 
43442  ShaderKit & SetParameterizationSource(Shader::Parameterization in_source);
43443 
43447  ShaderKit & SetTransformMatrix(MatrixKit const & in_transform);
43448 
43451  ShaderKit & UnsetSource();
43452 
43456  ShaderKit & UnsetMultitexture();
43457 
43460  ShaderKit & UnsetParameterizationSource();
43461 
43464  ShaderKit & UnsetTransformMatrix();
43465 
43468  ShaderKit & UnsetEverything();
43469 
43473  bool ShowSource(UTF8 & out_source) const;
43474 
43480  bool ShowMultitexture(bool & out_state) const;
43481 
43485  bool ShowParameterizationSource(Shader::Parameterization & out_source) const;
43486 
43490  bool ShowTransformMatrix(MatrixKit & out_transform) const;
43491 };
43492 
43493 
43495 class HPS_API ShaderDefinition : public Definition
43496 {
43497 public:
43499  ShaderDefinition();
43500 
43505  ShaderDefinition(Definition const & in_that);
43506 
43509  ShaderDefinition(ShaderDefinition const & in_that);
43510 
43514  ShaderDefinition & operator=(ShaderDefinition const & in_that);
43515 
43519  ShaderDefinition(ShaderDefinition && in_that);
43520 
43524  ShaderDefinition & operator=(ShaderDefinition && in_that);
43525 
43526  ~ShaderDefinition();
43527 
43528  static const HPS::Type staticType = HPS::Type::ShaderDefinition;
43529  HPS::Type ObjectType() const { return staticType; };
43530 
43533  void Set(ShaderKit const & in_kit);
43534 
43537  void Show(ShaderKit & out_kit) const;
43538 };
43539 
43541 class HPS_API ShapeKit : public Kit
43542 {
43543 public:
43545  ShapeKit();
43546 
43549  ShapeKit(ShapeKit const & in_kit);
43550 
43554  ShapeKit(ShapeKit && in_that);
43555 
43559  ShapeKit & operator=(ShapeKit && in_that);
43560 
43561  virtual ~ShapeKit();
43562 
43563  static const HPS::Type staticType = HPS::Type::ShapeKit;
43564  HPS::Type ObjectType() const { return staticType; };
43565 
43568  void Set(ShapeKit const & in_kit);
43569 
43572  void Show(ShapeKit & out_kit) const;
43573 
43577  ShapeKit & operator=(ShapeKit const & in_kit);
43578 
43581  bool Empty() const;
43582 
43586  bool Equals(ShapeKit const & in_kit) const;
43587 
43591  bool operator==(ShapeKit const & in_kit) const;
43592 
43596  bool operator!=(ShapeKit const & in_kit) const;
43597 
43601  static HPS::ShapeKit GetDefault(Shape::Default in_default_shape);
43602 
43606  ShapeKit & SetElements(ShapeElementArray const & in_def);
43607 
43612  ShapeKit & SetElements(size_t in_count, ShapeElement const in_def []);
43613 
43617  ShapeKit & SetElement(ShapeElement const & in_element);
43618 
43621  ShapeKit & UnsetElements();
43622 
43625  ShapeKit & UnsetEverything();
43626 
43630  bool ShowElements(ShapeElementArray & out_def) const;
43631 
43632 };
43633 
43635 class HPS_API ShapeDefinition : public Definition
43636 {
43637 public:
43639  ShapeDefinition();
43640 
43645  ShapeDefinition(Definition const & in_that);
43646 
43649  ShapeDefinition(ShapeDefinition const & in_that);
43650 
43654  ShapeDefinition & operator=(ShapeDefinition const & in_that);
43655 
43659  ShapeDefinition(ShapeDefinition && in_that);
43660 
43664  ShapeDefinition & operator=(ShapeDefinition && in_that);
43665 
43666  ~ShapeDefinition();
43667 
43668  static const HPS::Type staticType = HPS::Type::ShapeDefinition;
43669  HPS::Type ObjectType() const { return staticType; };
43670 
43673  void Set(ShapeKit const & in_kit);
43674 
43677  void Show(ShapeKit & out_kit) const;
43678 };
43679 
43680 
43684 class HPS_API CutGeometryGatheringOptionsKit : public Kit
43685 {
43686 public:
43689 
43693 
43698 
43703 
43704  virtual ~CutGeometryGatheringOptionsKit();
43705 
43706  static const HPS::Type staticType = HPS::Type::CutGeometryGatheringOptionsKit;
43707  HPS::Type ObjectType() const {return staticType;};
43708 
43712  static CutGeometryGatheringOptionsKit GetDefault();
43713 
43716  void Set(CutGeometryGatheringOptionsKit const & in_kit);
43717 
43720  void Show(CutGeometryGatheringOptionsKit & out_kit) const;
43721 
43726 
43729  bool Empty() const;
43730 
43734  bool Equals(CutGeometryGatheringOptionsKit const & in_kit) const;
43735 
43739  bool operator==(CutGeometryGatheringOptionsKit const & in_kit) const;
43740 
43744  bool operator!=(CutGeometryGatheringOptionsKit const & in_kit) const;
43745 
43746 
43750  CutGeometryGatheringOptionsKit & SetCuttingSection(CuttingSectionKey const & in_cutter);
43751 
43755  CutGeometryGatheringOptionsKit & SetOffset(size_t in_offset);
43756 
43761 
43765  CutGeometryGatheringOptionsKit & SetColor(bool in_color);
43766 
43767 
43770  CutGeometryGatheringOptionsKit & UnsetCuttingSection();
43771 
43774  CutGeometryGatheringOptionsKit & UnsetOffset();
43775 
43778  CutGeometryGatheringOptionsKit & UnsetLevel();
43779 
43782  CutGeometryGatheringOptionsKit & UnsetColor();
43783 
43786  CutGeometryGatheringOptionsKit & UnsetEverything();
43787 
43788 
43792  bool ShowCuttingSection(CuttingSectionKey & out_cutter) const;
43793 
43797  bool ShowOffset(size_t & out_offset) const;
43798 
43802  bool ShowLevel(CuttingSection::GatheringLevel & out_level) const;
43803 
43807  bool ShowColor(bool & out_color) const;
43808 };
43809 
43811 class HPS_API SearchOptionsKit : public Kit
43812 {
43813 public:
43815  SearchOptionsKit();
43816 
43819  SearchOptionsKit(SearchOptionsKit const & in_kit);
43820 
43824  SearchOptionsKit(SearchOptionsKit && in_that);
43825 
43829  SearchOptionsKit & operator=(SearchOptionsKit && in_that);
43830 
43831  virtual ~SearchOptionsKit();
43832 
43833  static const HPS::Type staticType = HPS::Type::SearchOptionsKit;
43834  HPS::Type ObjectType() const {return staticType;};
43835 
43839  static SearchOptionsKit GetDefault();
43840 
43843  void Set(SearchOptionsKit const & in_kit);
43844 
43847  void Show(SearchOptionsKit & out_kit) const;
43848 
43852  SearchOptionsKit & operator=(SearchOptionsKit const & in_kit);
43853 
43856  bool Empty() const;
43857 
43861  bool Equals(SearchOptionsKit const & in_kit) const;
43862 
43866  bool operator==(SearchOptionsKit const & in_kit) const;
43867 
43871  bool operator!=(SearchOptionsKit const & in_kit) const;
43872 
43876  SearchOptionsKit & SetCriteria(Search::Type in_request);
43877 
43881  SearchOptionsKit & SetBehavior(Search::Behavior in_behavior);
43882 
43886  SearchOptionsKit & SetCriteria(SearchTypeArray const & in_requests);
43887 
43892  SearchOptionsKit & SetCriteria(size_t in_count, Search::Type const in_requests []);
43893 
43897  SearchOptionsKit & SetSearchSpace(Search::Space in_search_space);
43898 
43901  SearchOptionsKit & UnsetBehavior();
43902 
43905  SearchOptionsKit & UnsetCriteria();
43906 
43909  SearchOptionsKit & UnsetSearchSpace();
43910 
43913  SearchOptionsKit & UnsetEverything();
43914 
43918  bool ShowBehavior(Search::Behavior & out_behavior) const;
43919 
43923  bool ShowCriteria(SearchTypeArray & out_types) const;
43924 
43928  bool ShowSearchSpace(Search::Space & out_search_space) const;
43929 };
43930 
43934 class HPS_API TreeContext : public Object
43935 {
43936 public:
43939  TreeContext(bool in_create = true);
43940 
43943  TreeContext(TreeContext const & in_that);
43944 
43948  TreeContext(TreeContext && in_that);
43949 
43953  TreeContext & operator=(TreeContext && in_that);
43954 
43956  virtual ~TreeContext();
43957 
43958  static const HPS::Type staticType = HPS::Type::TreeContext;
43959  HPS::Type ObjectType() const {return staticType;};
43960 
43964  TreeContext & operator=(TreeContext const & in_that);
43965 
43969  bool Equals(TreeContext const & in_that) const;
43970 
43974  bool operator==(TreeContext const & in_that) const;
43975 
43979  bool operator!=(TreeContext const & in_that) const;
43980 
43981 };
43982 
43984 class HPS_API SelectionOptionsKit : public Kit
43985 {
43986 public:
43989 
43992  SelectionOptionsKit(SelectionOptionsKit const & in_kit);
43993 
43998 
44002  SelectionOptionsKit & operator=(SelectionOptionsKit && in_that);
44003 
44004  virtual ~SelectionOptionsKit();
44005 
44006  static const HPS::Type staticType = HPS::Type::SelectionOptionsKit;
44007  HPS::Type ObjectType() const {return staticType;};
44008 
44012  static SelectionOptionsKit GetDefault();
44013 
44016  void Set(SelectionOptionsKit const & in_kit);
44017 
44020  void Show(SelectionOptionsKit & out_kit) const;
44021 
44025  SelectionOptionsKit & operator=(SelectionOptionsKit const & in_kit);
44026 
44029  bool Empty() const;
44030 
44034  bool Equals(SelectionOptionsKit const & in_kit) const;
44035 
44039  bool operator==(SelectionOptionsKit const & in_kit) const;
44040 
44044  bool operator!=(SelectionOptionsKit const & in_kit) const;
44045 
44075  SelectionOptionsKit & SetProximity(float in_proximity);
44076 
44082  SelectionOptionsKit & SetLevel(Selection::Level in_level);
44083 
44089  SelectionOptionsKit & SetInternalLimit(size_t in_limit);
44090 
44101  SelectionOptionsKit & SetRelatedLimit(size_t in_limit);
44102 
44110  SelectionOptionsKit & SetSorting(bool in_sorting);
44111 
44128  SelectionOptionsKit & SetSorting(Selection::Sorting in_sorting);
44129 
44135  SelectionOptionsKit & SetAlgorithm(Selection::Algorithm in_algorithm);
44136 
44142  SelectionOptionsKit & SetGranularity(Selection::Granularity in_granularity);
44143 
44150  SelectionOptionsKit & SetScope(SegmentKey const & in_start_segment, bool in_scope_only = false);
44151 
44158  SelectionOptionsKit & SetScope(KeyPath const & in_start_path, bool in_scope_only = false);
44159 
44164  SelectionOptionsKit & SetTreeContext(TreeContext const & in_tree_context);
44165 
44172  SelectionOptionsKit & SetExtentCullingRespected(bool in_state);
44173 
44180  SelectionOptionsKit & SetDeferralExtentCullingRespected(bool in_state);
44181 
44188  SelectionOptionsKit & SetFrustumCullingRespected(bool in_state);
44189 
44196  SelectionOptionsKit & SetVectorCullingRespected(bool in_state);
44197 
44204  SelectionOptionsKit & SetVolumeCullingRespected(bool in_state);
44205 
44212  SelectionOptionsKit & SetDistanceCullingRespected(bool in_state);
44213 
44217  SelectionOptionsKit & SetSelectability(SelectabilityKit const & in_selectability);
44218 
44223  SelectionOptionsKit & SetCondition(char const * in_condition);
44224 
44229  SelectionOptionsKit & SetConditions(UTF8Array const & in_conditions);
44230 
44235  SelectionOptionsKit & SetConditions(size_t in_count, UTF8 const in_conditions[]);
44236 
44237 
44240  SelectionOptionsKit & UnsetSelectability();
44241 
44244  SelectionOptionsKit & UnsetProximity();
44245 
44248  SelectionOptionsKit & UnsetLevel();
44249 
44252  SelectionOptionsKit & UnsetInternalLimit();
44253 
44256  SelectionOptionsKit & UnsetRelatedLimit();
44257 
44260  SelectionOptionsKit & UnsetSorting();
44261 
44264  SelectionOptionsKit & UnsetAlgorithm();
44265 
44268  SelectionOptionsKit & UnsetGranularity();
44269 
44272  SelectionOptionsKit & UnsetScope();
44273 
44276  SelectionOptionsKit & UnsetTreeContext();
44277 
44280  SelectionOptionsKit & UnsetExtentCullingRespected();
44281 
44284  SelectionOptionsKit & UnsetDeferralExtentCullingRespected();
44285 
44288  SelectionOptionsKit & UnsetFrustumCullingRespected();
44289 
44292  SelectionOptionsKit & UnsetVectorCullingRespected();
44293 
44296  SelectionOptionsKit & UnsetVolumeCullingRespected();
44297 
44300  SelectionOptionsKit & UnsetDistanceCullingRespected();
44301 
44303  SelectionOptionsKit & UnsetConditions();
44304 
44307  SelectionOptionsKit & UnsetEverything();
44308 
44309 
44313  bool ShowProximity(float & out_proximity) const;
44314 
44318  bool ShowLevel(Selection::Level & out_level) const;
44319 
44323  bool ShowInternalLimit(size_t & out_limit) const;
44324 
44328  bool ShowRelatedLimit(size_t & out_limit) const;
44329 
44333  bool ShowSorting(Selection::Sorting & out_sorting) const;
44334 
44338  bool ShowAlgorithm(Selection::Algorithm & out_algorithm) const;
44339 
44343  bool ShowGranularity(Selection::Granularity & out_granularity) const;
44344 
44350  bool ShowScope(KeyPath & out_start_path, bool & out_scope_only) const;
44351 
44355  bool ShowTreeContext(TreeContext & out_tree_context) const;
44356 
44360  bool ShowExtentCullingRespected(bool & out_state) const;
44361 
44365  bool ShowDeferralExtentCullingRespected(bool & out_state) const;
44366 
44370  bool ShowFrustumCullingRespected(bool & out_state) const;
44371 
44375  bool ShowVectorCullingRespected(bool & out_state) const;
44376 
44380  bool ShowVolumeCullingRespected(bool & out_state) const;
44381 
44385  bool ShowDistanceCullingRespected(bool & out_state) const;
44386 
44390  bool ShowSelectability(HPS::SelectabilityKit & out_selectability) const;
44391 
44394  bool ShowConditions(UTF8Array & out_conditions) const;
44395 };
44396 
44397 
44398 
44402 class HPS_API SelectionOptionsControl : public Control
44403 {
44404 public:
44407  explicit SelectionOptionsControl(WindowKey const & in_window);
44408 
44412 
44417 
44421  SelectionOptionsControl & operator=(SelectionOptionsControl && in_that);
44422 
44424 
44425  virtual HPS::Type Type() const { return ObjectType(); }
44426 
44427  static const HPS::Type staticType = HPS::Type::SelectionOptionsControl;
44428  HPS::Type ObjectType() const {return staticType;};
44429 
44433  SelectionOptionsControl & operator=(SelectionOptionsControl const & in_that);
44434 
44464  SelectionOptionsControl & SetProximity(float in_proximity);
44465 
44471  SelectionOptionsControl & SetLevel(Selection::Level in_level);
44472 
44479  SelectionOptionsControl & SetInternalLimit(size_t in_limit);
44480 
44490  SelectionOptionsControl & SetRelatedLimit(size_t in_limit);
44491 
44499  SelectionOptionsControl & SetSorting(bool in_sorting);
44500 
44517  SelectionOptionsControl & SetSorting(Selection::Sorting in_sorting);
44518 
44524  SelectionOptionsControl & SetAlgorithm(Selection::Algorithm in_algorithm);
44525 
44531  SelectionOptionsControl & SetGranularity(Selection::Granularity in_granularity);
44532 
44539  SelectionOptionsControl & SetExtentCullingRespected(bool in_state);
44540 
44547  SelectionOptionsControl & SetDeferralExtentCullingRespected(bool in_state);
44548 
44555  SelectionOptionsControl & SetFrustumCullingRespected(bool in_state);
44556 
44563  SelectionOptionsControl & SetVectorCullingRespected(bool in_state);
44564 
44571  SelectionOptionsControl & SetVolumeCullingRespected(bool in_state);
44572 
44579  SelectionOptionsControl & SetDistanceCullingRespected(bool in_state);
44580 
44581 
44585  SelectionOptionsControl & UnsetProximity();
44586 
44590  SelectionOptionsControl & UnsetLevel();
44591 
44595  SelectionOptionsControl & UnsetInternalLimit();
44596 
44600  SelectionOptionsControl & UnsetRelatedLimit();
44601 
44605  SelectionOptionsControl & UnsetSorting();
44606 
44610  SelectionOptionsControl & UnsetAlgorithm();
44611 
44615  SelectionOptionsControl & UnsetGranularity();
44616 
44620  SelectionOptionsControl & UnsetExtentCullingRespected();
44621 
44625  SelectionOptionsControl & UnsetDeferralExtentCullingRespected();
44626 
44630  SelectionOptionsControl & UnsetFrustumCullingRespected();
44631 
44635  SelectionOptionsControl & UnsetVectorCullingRespected();
44636 
44640  SelectionOptionsControl & UnsetVolumeCullingRespected();
44641 
44645  SelectionOptionsControl & UnsetDistanceCullingRespected();
44646 
44650  SelectionOptionsControl & UnsetEverything();
44651 
44655  bool ShowProximity(float & out_proximity) const;
44656 
44660  bool ShowLevel(Selection::Level & out_level) const;
44661 
44665  bool ShowInternalLimit(size_t & out_limit) const;
44666 
44670  bool ShowRelatedLimit(size_t & out_limit) const;
44671 
44675  bool ShowSorting(Selection::Sorting & out_sorting) const;
44676 
44680  bool ShowAlgorithm(Selection::Algorithm & out_algorithm) const;
44681 
44685  bool ShowGranularity(Selection::Granularity & out_granularity) const;
44686 
44690  bool ShowExtentCullingRespected(bool & out_state) const;
44691 
44695  bool ShowDeferralExtentCullingRespected(bool & out_state) const;
44696 
44700  bool ShowFrustumCullingRespected(bool & out_state) const;
44701 
44705  bool ShowVectorCullingRespected(bool & out_state) const;
44706 
44710  bool ShowVolumeCullingRespected(bool & out_state) const;
44711 
44715  bool ShowDistanceCullingRespected(bool & out_state) const;
44716 
44717 private:
44720 };
44721 
44722 
44723 
44725 class HPS_API SelectionItem : public Object
44726 {
44727 public:
44729  SelectionItem();
44730 
44733  SelectionItem(SelectionItem const & in_that);
44734 
44738  SelectionItem(SelectionItem && in_that);
44739 
44743  SelectionItem & operator=(SelectionItem && in_that);
44744 
44745  virtual ~SelectionItem();
44746 
44747  static const HPS::Type staticType = HPS::Type::SelectionItem;
44748  HPS::Type ObjectType() const {return staticType;};
44749 
44752  void Set(SelectionItem const & in_that);
44753 
44757  SelectionItem & operator=(SelectionItem const & in_that);
44758 
44762  bool Equals(SelectionItem const & in_that) const;
44763 
44767  bool operator==(SelectionItem const & in_that) const;
44768 
44772  bool operator!=(SelectionItem const & in_that) const;
44773 
44777  bool ShowSelectionLevel(Selection::Level & out_level) const;
44778 
44782  bool ShowSelectedItem(Key & out_selection) const;
44783 
44787  bool ShowPath(KeyPath & out_path) const;
44788 
44792  bool ShowFaces(SizeTArray & out_faces) const;
44793 
44797  bool ShowVertices(SizeTArray & out_vertices) const;
44798 
44803  bool ShowEdges(SizeTArray & out_vertices1, SizeTArray & out_vertices2) const;
44804 
44808  bool ShowCharacters(SizeTArray & out_characters) const;
44809 
44813  bool ShowSelectionPosition(WindowPoint & out_location) const;
44814 
44818  bool ShowSelectionPosition(WorldPoint & out_location) const;
44819 
44823  bool ShowNormalizedSelectionPosition(WindowPoint & out_location) const;
44824 
44825 };
44826 
44828 class HPS_API SelectionResultsIterator : public Object
44829 {
44830 public:
44833 
44838 
44843 
44847  SelectionResultsIterator & operator=(SelectionResultsIterator && in_that);
44848 
44850 
44851  static const HPS::Type staticType = HPS::Type::SelectionResultsIterator;
44852  HPS::Type ObjectType() const {return staticType;}
44853 
44857  SelectionResultsIterator & operator=(SelectionResultsIterator const & in_that);
44858 
44861  void Set(SelectionResultsIterator const & in_that);
44862 
44864  void Next();
44865 
44868  SelectionResultsIterator & operator++();
44869 
44872  SelectionResultsIterator operator++(int in_val);
44873 
44876  bool operator==(SelectionResultsIterator const & in_search_results_iterator);
44877 
44880  bool operator!=(SelectionResultsIterator const & in_search_results_iterator);
44881 
44882 
44885  bool IsValid() const;
44886 
44888  void Reset();
44889 
44892  SelectionItem GetItem() const;
44893 
44896  SelectionItem operator*() const;
44897 
44898 
44899 };
44900 
44904 class HPS_API SelectionResults : public Object
44905 {
44906 public:
44908  SelectionResults();
44909 
44912  SelectionResults(SelectionResults const & in_that);
44913 
44917  SelectionResults(SelectionResults && in_that);
44918 
44922  SelectionResults & operator=(SelectionResults && in_that);
44923 
44924  ~SelectionResults();
44925 
44926  static const HPS::Type staticType = HPS::Type::SelectionResults;
44927  HPS::Type ObjectType() const {return staticType;}
44928 
44931  void Assign(SelectionResults const & in_that);
44932 
44936  SelectionResults & operator=(SelectionResults const & in_that);
44937 
44941  bool Equals(SelectionResults const & in_that) const;
44942 
44946  bool operator==(SelectionResults const & in_that) const;
44947 
44951  bool operator!=(SelectionResults const & in_that) const;
44952 
44954  virtual void Reset();
44955 
44958  Selection::Level GetSelectionLevel() const;
44959 
44962  size_t GetCount() const;
44963 
44966  SelectionResultsIterator GetIterator() const;
44967 
44973  bool Union(SelectionResults const & in_that);
44974 
44979  bool Intersect(SelectionResults const & in_that);
44980 
44986  bool SymmetricDifference(SelectionResults const & in_that);
44987 
44992  bool Difference(SelectionResults const & in_that);
44993 
44996  void Copy(SelectionResults const & in_that);
44997 };
44998 
45001 class HPS_API SelectionControl : public Control
45002 {
45003 public:
45006  explicit SelectionControl(WindowKey const & in_window);
45007 
45010  SelectionControl(SelectionControl const & in_that);
45011 
45015  SelectionControl(SelectionControl && in_that);
45016 
45020  SelectionControl & operator=(SelectionControl && in_that);
45021 
45022  ~SelectionControl();
45023 
45024  static const HPS::Type staticType = HPS::Type::SelectionControl;
45025  HPS::Type ObjectType() const {return staticType;};
45026 
45030  SelectionControl & operator=(SelectionControl const & in_that);
45031 
45037  size_t SelectByPoint(Point const & in_location, SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
45038 
45043  size_t SelectByPoint(Point const & in_location, SelectionResults & out_results) const;
45044 
45050  size_t SelectByArea(Rectangle const & in_area, SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
45051 
45056  size_t SelectByArea(Rectangle const & in_area, SelectionResults & out_results) const;
45057 
45063  size_t SelectByPolygon(PointArray const & in_points, SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
45064 
45069  size_t SelectByPolygon(PointArray const & in_points, SelectionResults & out_results) const;
45070 
45077  size_t SelectByPolygon(size_t in_point_count, Point const in_points [], SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
45078 
45084  size_t SelectByPolygon(size_t in_point_count, Point const in_points [], SelectionResults & out_results) const;
45085 
45091  size_t SelectByLine(PointArray const & in_points, SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
45092 
45097  size_t SelectByLine(PointArray const & in_points, SelectionResults & out_results) const;
45098 
45105  size_t SelectByLine(size_t in_point_count, Point const in_points [], SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
45106 
45112  size_t SelectByLine(size_t in_point_count, Point const in_points [], SelectionResults & out_results) const;
45113 
45114 
45115  //Object space selections
45116 
45122  size_t SelectByShell(ShellKit const & in_shell, SelectionOptionsKit const & in_options, SelectionResults & out_results);
45123 
45128  size_t SelectByShell(ShellKit const & in_shell, SelectionResults & out_results);
45129 
45135  size_t SelectByShell(ShellKey const & in_shell, SelectionOptionsKit const & in_options, SelectionResults & out_results);
45136 
45141  size_t SelectByShell(ShellKey const & in_shell, SelectionResults & out_results);
45142 
45143 
45150  size_t SelectByVolume(SimpleCuboid const & in_volume, SelectionOptionsKit const & in_options, SelectionResults & out_results);
45151 
45157  size_t SelectByVolume(SimpleCuboid const & in_volume, SelectionResults & out_results);
45158 
45159 
45166  size_t SelectByRay(Point const & in_start_point, Vector const & in_direction, SelectionOptionsKit const & in_options, SelectionResults & out_results);
45167 
45173  size_t SelectByRay(Point const & in_start_point, Vector const & in_direction, SelectionResults & out_results);
45174 
45175 private:
45177  SelectionControl();
45178 };
45179 
45180 
45181 
45183 class HPS_API HighlightOptionsKit : public Kit
45184 {
45185 public:
45188 
45191  HighlightOptionsKit(char const * in_style_name);
45192 
45196  HighlightOptionsKit(char const * in_style_name, char const * in_secondary_style_name);
45197 
45200  HighlightOptionsKit(HighlightOptionsKit const & in_kit);
45201 
45206 
45210  HighlightOptionsKit & operator=(HighlightOptionsKit && in_that);
45211 
45212  virtual ~HighlightOptionsKit();
45213 
45214  static const HPS::Type staticType = HPS::Type::HighlightOptionsKit;
45215  HPS::Type ObjectType() const {return staticType;};
45216 
45220  static HighlightOptionsKit GetDefault();
45221 
45224  void Set(HighlightOptionsKit const & in_kit);
45225 
45228  void Show(HighlightOptionsKit & out_kit) const;
45229 
45233  HighlightOptionsKit & operator=(HighlightOptionsKit const & in_kit);
45234 
45237  bool Empty() const;
45238 
45242  bool Equals(HighlightOptionsKit const & in_kit) const;
45243 
45247  bool operator==(HighlightOptionsKit const & in_kit) const;
45248 
45252  bool operator!=(HighlightOptionsKit const & in_kit) const;
45253 
45259  HighlightOptionsKit & SetPassive(bool in_pasive);
45260 
45265  HighlightOptionsKit & SetStyleName(char const * in_style_name);
45266 
45270  HighlightOptionsKit & SetSecondaryStyleName(char const * in_style_name);
45271 
45280  HighlightOptionsKit & SetOverlay(Drawing::Overlay in_overlay);
45281 
45287  HighlightOptionsKit & SetNotification(bool in_state);
45288 
45292  HighlightOptionsKit & SetSubentityHighlighting(bool in_enable);
45293 
45296  HighlightOptionsKit & UnsetPassive();
45297 
45300  HighlightOptionsKit & UnsetStyleName();
45301 
45304  HighlightOptionsKit & UnsetSecondaryStyleName();
45305 
45308  HighlightOptionsKit & UnsetOverlay();
45309 
45312  HighlightOptionsKit & UnsetNotification();
45313 
45316  HighlightOptionsKit & UnsetSubentityHighlighting();
45317 
45320  HighlightOptionsKit & UnsetEverything();
45321 
45325  bool ShowPassive(bool & out_pasive) const;
45326 
45330  bool ShowStyleName(UTF8 & out_style_name) const;
45331 
45335  bool ShowSecondaryStyleName(UTF8 & out_style_name) const;
45336 
45340  bool ShowOverlay(Drawing::Overlay & out_overlay) const;
45341 
45345  bool ShowNotification(bool & out_state) const;
45346 
45350  bool ShowSubentityHighlighting(bool & out_enable) const;
45351 };
45352 
45355 class HPS_API HighlightSearchOptionsKit : public Kit
45356 {
45357 public:
45360 
45364 
45369 
45373  HighlightSearchOptionsKit & operator=(HighlightSearchOptionsKit && in_that);
45374 
45375  virtual ~HighlightSearchOptionsKit();
45376 
45377  static const HPS::Type staticType = HPS::Type::HighlightSearchOptionsKit;
45378  HPS::Type ObjectType() const { return staticType; };
45379 
45383  static HighlightSearchOptionsKit GetDefault();
45384 
45387  void Set(HighlightSearchOptionsKit const & in_kit);
45388 
45391  void Show(HighlightSearchOptionsKit & out_kit) const;
45392 
45396  HighlightSearchOptionsKit & operator=(HighlightSearchOptionsKit const & in_kit);
45397 
45400  bool Empty() const;
45401 
45405  bool Equals(HighlightSearchOptionsKit const & in_kit) const;
45406 
45410  bool operator==(HighlightSearchOptionsKit const & in_kit) const;
45411 
45415  bool operator!=(HighlightSearchOptionsKit const & in_kit) const;
45416 
45417 
45421  HighlightSearchOptionsKit & SetStyleName(char const * in_style_name);
45422 
45426  HighlightSearchOptionsKit & SetStyleNames(UTF8Array const & in_style_names);
45427 
45431  HighlightSearchOptionsKit & SetOverlay(Drawing::Overlay in_overlay);
45432 
45436  HighlightSearchOptionsKit & SetOverlays(DrawingOverlayArray const & in_overlays);
45437 
45438 
45441  HighlightSearchOptionsKit & UnsetStyleNames();
45442 
45445  HighlightSearchOptionsKit & UnsetOverlays();
45446 
45449  HighlightSearchOptionsKit & UnsetEverything();
45450 
45451 
45455  bool ShowStyleNames(UTF8Array & out_style_names) const;
45456 
45460  bool ShowOverlays(DrawingOverlayArray & out_overlays) const;
45461 };
45462 
45464 class HPS_API HighlightState : public Object
45465 {
45466 public:
45468  HighlightState();
45469 
45472  HighlightState(HighlightState const & in_that);
45473 
45477  HighlightState(HighlightState && in_that);
45478 
45482  HighlightState & operator=(HighlightState && in_that);
45483 
45484  ~HighlightState();
45485 
45486  static const HPS::Type staticType = HPS::Type::HighlightState;
45487  HPS::Type ObjectType() const { return staticType; };
45488 
45491  void Assign(HighlightState const & in_that);
45492 
45496  HighlightState & operator=(HighlightState const & in_that);
45497 
45501  bool Equals(HighlightState const & in_that) const;
45502 
45506  bool operator== (HighlightState const & in_that) const;
45507 
45511  bool operator!= (HighlightState const & in_that) const;
45512 
45515  void Set(bool in_directly_highlighted, bool in_subentity_highlighted, bool in_inherits_highlight, bool in_on_highlight_path);
45516 
45519  bool GetDirectlyHighlighted() const;
45520 
45524  bool GetSubentityHighlighted() const;
45525 
45528  bool GetInheritsHighlight() const;
45529 
45532  bool GetOnHighlightPath() const;
45533 };
45534 
45537 {
45538 public:
45539 
45542 
45546  HighlightSearchResultsIterator(HighlightSearchResultsIterator const & in_search_results_iterator);
45547 
45552 
45557 
45559 
45560  static const HPS::Type staticType = HPS::Type::HighlightSearchResultsIterator;
45561  HPS::Type ObjectType() const { return staticType; }
45562 
45567  HighlightSearchResultsIterator & operator=(HighlightSearchResultsIterator const & in_search_results_iterator);
45568 
45573  void Set(HighlightSearchResultsIterator const & in_search_results_iterator);
45574 
45576  void Next();
45577 
45580  HighlightSearchResultsIterator & operator++();
45581 
45584  HighlightSearchResultsIterator operator++(int in_val);
45585 
45588  bool operator==(HighlightSearchResultsIterator const & in_search_results_iterator);
45589 
45592  bool operator!=(HighlightSearchResultsIterator const & in_search_results_iterator);
45593 
45597  bool IsValid() const;
45598 
45600  void Reset();
45601 
45605  KeyPath GetItem() const;
45606 
45609  KeyPath operator*() const;
45610 
45614  UTF8 GetStyleName() const;
45615 
45619  Drawing::Overlay GetOverlay() const;
45620 
45624  bool GetPassive() const;
45625 };
45626 
45628 class HPS_API HighlightSearchResults : public Object
45629 {
45630 public:
45633 
45636  HighlightSearchResults(HighlightSearchResults const & in_search_results);
45637 
45642 
45646  HighlightSearchResults & operator=(HighlightSearchResults && in_that);
45647 
45649  virtual void Reset();
45650 
45653 
45654  static const HPS::Type staticType = HPS::Type::HighlightSearchResults;
45655  HPS::Type ObjectType() const { return staticType; }
45656 
45660  void Assign(HighlightSearchResults const & in_search_results);
45661 
45665  HighlightSearchResults & operator=(HighlightSearchResults const & in_search_results);
45666 
45669  size_t GetCount() const;
45670 
45673  HighlightSearchResultsIterator GetIterator() const;
45674 };
45675 
45676 
45677 
45680 {
45681 public:
45682 
45685 
45689  OptimizeMappingResultsIterator(OptimizeMappingResultsIterator const & in_mapping_results_iterator);
45690 
45695 
45700 
45702 
45703  static const HPS::Type staticType = HPS::Type::OptimizeMappingResultsIterator;
45704  HPS::Type ObjectType() const { return staticType; }
45705 
45710  OptimizeMappingResultsIterator & operator=(OptimizeMappingResultsIterator const & in_mapping_results_iterator);
45711 
45716  void Set(OptimizeMappingResultsIterator const & in_mapping_results_iterator);
45717 
45719  void Next();
45720 
45723  OptimizeMappingResultsIterator & operator++();
45724 
45727  OptimizeMappingResultsIterator operator++(int in_val);
45728 
45731  bool operator==(OptimizeMappingResultsIterator const & in_mapping_results_iterator);
45732 
45735  bool operator!=(OptimizeMappingResultsIterator const & in_mapping_results_iterator);
45736 
45740  bool IsValid() const;
45741 
45743  void Reset();
45744 
45748  Key GetItem() const;
45749 
45752  Key operator*() const;
45753 
45760  bool GetMergedShellInfo(ShellKey & out_shell_key, size_t & out_vertex_offset, size_t & out_face_offset, size_t & out_edge_offset) const;
45761 
45762 };
45763 
45765 class HPS_API OptimizeMappingResults : public Object
45766 {
45767 public:
45770 
45773  OptimizeMappingResults(OptimizeMappingResults const & in_mappping);
45774 
45779 
45783  OptimizeMappingResults & operator=(OptimizeMappingResults && in_that);
45784 
45786  virtual void Reset();
45787 
45790 
45791  static const HPS::Type staticType = HPS::Type::OptimizeMappingResults;
45792  HPS::Type ObjectType() const { return staticType; }
45793 
45797  void Assign(OptimizeMappingResults const & in_mappping);
45798 
45802  OptimizeMappingResults & operator=(OptimizeMappingResults const & in_mappping);
45803 
45806  size_t GetCount() const;
45807 
45811  bool FlushMerged();
45812 
45815  OptimizeMappingResultsIterator GetIterator() const;
45816 };
45817 
45818 
45821 class HPS_API HighlightControl : public Control
45822 {
45823 public:
45826  explicit HighlightControl(WindowKey const & in_window);
45827 
45830  HighlightControl(HighlightControl const & in_that);
45831 
45835  HighlightControl(HighlightControl && in_that);
45836 
45840  HighlightControl & operator=(HighlightControl && in_that);
45841 
45842  ~HighlightControl();
45843 
45844  virtual HPS::Type Type() const { return ObjectType(); }
45845 
45846  static const HPS::Type staticType = HPS::Type::HighlightControl;
45847  HPS::Type ObjectType() const {return staticType;};
45848 
45852  HighlightControl & operator=(HighlightControl const & in_that);
45853 
45859  HighlightControl & Highlight(SelectionResults const & in_items, HighlightOptionsKit const & in_options, bool in_remove_existing = true);
45860 
45866  HighlightControl & Highlight(SelectionItem const & in_item, HighlightOptionsKit const & in_options, bool in_remove_existing = true);
45867 
45873  HighlightControl & Highlight(SearchResults const & in_items, HighlightOptionsKit const & in_options, bool in_remove_existing = true);
45874 
45880  HighlightControl & Highlight(KeyPath const & in_item, HighlightOptionsKit const & in_options, bool in_remove_existing = true);
45881 
45887  HighlightControl & Highlight(Key const & in_item, HighlightOptionsKit const & in_options, bool in_remove_existing = true);
45888 
45898  HighlightControl & Highlight(KeyPath const & in_item, HighlightOptionsKit const & in_options, SizeTArray const & in_vertices, SizeTArray const & in_edges1, SizeTArray const & in_edges2, SizeTArray const & in_faces, bool in_remove_existing = true);
45899 
45909  HighlightControl & Highlight(Key const & in_item, HighlightOptionsKit const & in_options, SizeTArray const & in_vertices, SizeTArray const & in_edges1, SizeTArray const & in_edges2, SizeTArray const & in_faces, bool in_remove_existing = true);
45910 
45923  HighlightControl & Highlight(
45924  KeyPath const & in_item,
45925  HighlightOptionsKit const & in_options,
45926  size_t in_vertices_count,
45927  size_t const in_vertices[],
45928  size_t in_edges_count,
45929  size_t const in_edges1[],
45930  size_t const in_edges2[],
45931  size_t in_faces_count,
45932  size_t const in_faces[],
45933  bool in_remove_existing = true);
45934 
45947  HighlightControl & Highlight(
45948  Key const & in_item,
45949  HighlightOptionsKit const & in_options,
45950  size_t in_vertices_count,
45951  size_t const in_vertices[],
45952  size_t in_edges_count,
45953  size_t const in_edges1[],
45954  size_t const in_edges2[],
45955  size_t in_faces_count,
45956  size_t const in_faces[],
45957  bool in_remove_existing = true);
45958 
45963  HighlightControl & Unhighlight(SelectionResults const & in_items, HighlightOptionsKit const & in_options = HighlightOptionsKit());
45964 
45969  HighlightControl & Unhighlight(SelectionItem const & in_item, HighlightOptionsKit const & in_options = HighlightOptionsKit());
45970 
45975  HighlightControl & Unhighlight(SearchResults const & in_items, HighlightOptionsKit const & in_options = HighlightOptionsKit());
45976 
45981  HighlightControl & Unhighlight(KeyPath const & in_item, HighlightOptionsKit const & in_options = HighlightOptionsKit());
45982 
45987  HighlightControl & Unhighlight(Key const & in_item, HighlightOptionsKit const & in_options = HighlightOptionsKit());
45988 
45997  HighlightControl & Unhighlight(KeyPath const & in_item, HighlightOptionsKit const & in_options, SizeTArray const & in_vertices, SizeTArray const & in_edges1, SizeTArray const & in_edges2, SizeTArray const & in_faces);
45998 
46007  HighlightControl & Unhighlight(Key const & in_item, HighlightOptionsKit const & in_options, SizeTArray const & in_vertices, SizeTArray const & in_edges1, SizeTArray const & in_edges2, SizeTArray const & in_faces);
46008 
46020  HighlightControl & Unhighlight(
46021  KeyPath const & in_item,
46022  HighlightOptionsKit const & in_options,
46023  size_t in_vertices_count,
46024  size_t const in_vertices[],
46025  size_t in_edges_count,
46026  size_t const in_edges1[],
46027  size_t const in_edges2[],
46028  size_t in_faces_count,
46029  size_t const in_faces[]);
46030 
46042  HighlightControl & Unhighlight(
46043  Key const & in_item,
46044  HighlightOptionsKit const & in_options,
46045  size_t in_vertices_count,
46046  size_t const in_vertices[],
46047  size_t in_edges_count,
46048  size_t const in_edges1[],
46049  size_t const in_edges2[],
46050  size_t in_faces_count,
46051  size_t const in_faces[]);
46052 
46056  HighlightControl & Unhighlight(HighlightOptionsKit const & in_options);
46057 
46060  HighlightControl & UnhighlightEverything();
46061 
46066  void ShowHighlightState(
46067  Key const & in_key,
46068  HighlightSearchOptionsKit const & in_search_options,
46069  HighlightState & out_state) const;
46070 
46075  void ShowHighlightState(
46076  KeyPath const & in_key_path,
46077  HighlightSearchOptionsKit const & in_search_options,
46078  HighlightState & out_state) const;
46079 
46084  void ShowHighlightStates(
46085  KeyArray const & in_keys,
46086  HighlightSearchOptionsKit const & in_search_options,
46087  HighlightStateArray & out_states) const;
46088 
46093  void ShowHighlightStates(
46094  KeyPathArray const & in_key_paths,
46095  HighlightSearchOptionsKit const & in_search_options,
46096  HighlightStateArray & out_states) const;
46097 
46098 private:
46100  HighlightControl();
46101 };
46102 
46104 class HPS_API UpdateOptionsKit : public Kit
46105 {
46106 public:
46108  UpdateOptionsKit();
46109 
46112  UpdateOptionsKit(UpdateOptionsKit const & in_kit);
46113 
46117  UpdateOptionsKit(UpdateOptionsKit && in_that);
46118 
46122  UpdateOptionsKit & operator=(UpdateOptionsKit && in_that);
46123 
46124  virtual ~UpdateOptionsKit();
46125 
46126  static const HPS::Type staticType = HPS::Type::UpdateOptionsKit;
46127  HPS::Type ObjectType() const {return staticType;};
46128 
46132  static UpdateOptionsKit GetDefault();
46133 
46136  void Set(UpdateOptionsKit const & in_kit);
46137 
46140  void Show(UpdateOptionsKit & out_kit) const;
46141 
46145  UpdateOptionsKit & operator=(UpdateOptionsKit const & in_kit);
46146 
46149  bool Empty() const;
46150 
46154  bool Equals(UpdateOptionsKit const & in_kit) const;
46155 
46159  bool operator==(UpdateOptionsKit const & in_kit) const;
46160 
46164  bool operator!=(UpdateOptionsKit const & in_kit) const;
46165 
46169  UpdateOptionsKit & SetUpdateType(HPS::Window::UpdateType in_type);
46170 
46174  UpdateOptionsKit & SetTimeLimit(HPS::Time in_time_limit);
46175 
46178  UpdateOptionsKit & UnsetUpdateType();
46179 
46182  UpdateOptionsKit & UnsetTimeLimit();
46183 
46186  UpdateOptionsKit & UnsetEverything();
46187 
46188 
46192  bool ShowUpdateType(HPS::Window::UpdateType & out_type) const;
46193 
46197  bool ShowTimeLimit(HPS::Time & out_time_limit) const;
46198 
46199 };
46200 
46201 
46202 
46208 class HPS_API UpdateOptionsControl : public Control
46209 {
46210 public:
46213  explicit UpdateOptionsControl(WindowKey const & in_window);
46214 
46217  UpdateOptionsControl(UpdateOptionsControl const & in_that);
46218 
46223 
46227  UpdateOptionsControl & operator=(UpdateOptionsControl && in_that);
46228 
46230 
46231  virtual HPS::Type Type() const { return ObjectType(); }
46232 
46233  static const HPS::Type staticType = HPS::Type::UpdateOptionsControl;
46234  HPS::Type ObjectType() const {return staticType;};
46235 
46239  UpdateOptionsControl & operator=(UpdateOptionsControl const & in_that);
46240 
46244  UpdateOptionsControl & SetUpdateType(HPS::Window::UpdateType in_type);
46245 
46249  UpdateOptionsControl & SetTimeLimit(HPS::Time in_time_limit);
46250 
46254  UpdateOptionsControl & UnsetUpdateType();
46255 
46259  UpdateOptionsControl & UnsetTimeLimit();
46260 
46264  UpdateOptionsControl & UnsetEverything();
46265 
46269  bool ShowUpdateType(HPS::Window::UpdateType & out_type) const;
46270 
46274  bool ShowTimeLimit(HPS::Time & out_time_limit) const;
46275 
46276 private:
46279 };
46280 
46283 class HPS_API World : public Object
46284 {
46285 public:
46292  World(char const * in_license, char const * in_code_generation_directory = nullptr);
46293 
46295  ~World();
46296 
46297  static const HPS::Type staticType = HPS::Type::World;
46298  HPS::Type ObjectType() const {return staticType;};
46299 
46304  World & SetMaterialLibraryDirectory(char const * in_directory);
46305 
46310  World & SetFontDirectory(char const * in_directory);
46311 
46317  World & SetFontDirectories(size_t in_count, UTF8 const in_directories[]);
46318 
46323  World & SetFontDirectories(UTF8Array const & in_directories);
46324 
46330  World & SetDriverConfigFile(char const * in_filename);
46331 
46337  World & SetExchangeLibraryDirectory(char const * in_directory);
46338 
46344  World & SetPublishResourceDirectory(char const * in_directory);
46345 
46351  World & SetParasolidSchemaDirectory(char const * in_directory);
46352 
46358  World & SetParasolidBodyshopDirectory(char const * in_directory);
46359 
46362  World & UnsetMaterialLibraryDirectory();
46363 
46366  World & UnsetFontDirectories();
46367 
46370  World & UnsetDriverConfigFile();
46371 
46374  World & UnsetExchangeLibraryDirectory();
46375 
46378  World & UnsetPublishResourceDirectory();
46379 
46382  World & UnsetParasolidSchemaDirectory();
46383 
46386  World & UnsetParasolidBodyshopDirectory();
46387 
46391  bool ShowMaterialLibraryDirectory(UTF8 & out_directory) const;
46392 
46396  bool ShowFontDirectories(UTF8Array & out_directories) const;
46397 
46401  bool ShowDriverConfigFile(UTF8 & out_filename) const;
46402 
46406  bool ShowExchangeLibraryDirectory(UTF8 & out_directory) const;
46407 
46411  bool ShowPublishResourceDirectory(UTF8 & out_directory) const;
46412 
46416  bool ShowParasolidSchemaDirectory(UTF8 & out_directory) const;
46417 
46421  bool ShowParasolidBodyshopDirectory(UTF8 & out_directory) const;
46422 
46426  static void AddCodeGenerationComment(UTF8 const & in_comment);
46427 
46429  static void StopCodeGeneration();
46430 
46431 private:
46433  World();
46434 
46436  virtual void Reset() {}
46437 };
46438 
46439 
46455 class HPS_API EmergencyHandler
46456 {
46457 public:
46458 
46461 
46462  virtual ~EmergencyHandler();
46463 
46465  intptr_t GetClassID() const;
46466 
46470  virtual void Handle(char const * message, HPS::Emergency::Code code) = 0;
46471 
46472  static void * operator new (size_t in_size){ return Memory::Allocate(in_size); }
46473  static void operator delete (void * in_ptr, size_t in_size) throw () { HPS_UNREFERENCED(in_size); Memory::Free(in_ptr); }
46474 };
46475 
46476 
46479 class HPS_API Database
46480 {
46481 public:
46486  static void Execute(bool in_once=true);
46487 
46490  static Time GetTime();
46491 
46493  static void Sleep(Time milliseconds);
46494 
46519  static void RelinquishMemory();
46520 
46521 
46547  static void ShowMemoryUsage(size_t & out_allocated, size_t & out_used);
46548 
46556  static void Reset();
46557 
46559  static void Synchronize();
46560 
46563  static WindowKeyArray GetWindowKeys();
46564 
46567  static SegmentKeyArray GetRootSegments();
46568 
46571  static PortfolioKeyArray GetPortfolios();
46572 
46577  static PortfolioKey const GetMaterialLibraryPortfolio();
46578 
46584  static ApplicationWindowKey CreateApplicationWindow(WindowHandle in_window_handle, Window::Driver in_driver = Window::Driver::Default3D);
46585 
46590  static ApplicationWindowKey CreateApplicationWindow(WindowHandle in_window_handle, ApplicationWindowOptionsKit const & in_options);
46591 
46595  static StandAloneWindowKey CreateStandAloneWindow(Window::Driver in_driver = Window::Driver::Default3D);
46596 
46600  static StandAloneWindowKey CreateStandAloneWindow(StandAloneWindowOptionsKit const & in_options);
46601 
46608  static OffScreenWindowKey CreateOffScreenWindow(unsigned int in_width, unsigned int in_height, Window::Driver in_driver = Window::Driver::Default3D);
46609 
46615  static OffScreenWindowKey CreateOffScreenWindow(unsigned int in_width, unsigned int in_height, OffScreenWindowOptionsKit const & in_options);
46616 
46622  static OffScreenWindowKey CreateOffScreenWindow(ImageDefinition const & in_destination_image, Window::Driver in_driver = Window::Driver::Default3D);
46623 
46628  static OffScreenWindowKey CreateOffScreenWindow(ImageDefinition const & in_destination_image, OffScreenWindowOptionsKit const & in_options);
46629 
46632  static SegmentKey CreateRootSegment();
46633 
46636  static PortfolioKey CreatePortfolio();
46637 
46640  static EventDispatcher CreateEventDispatcher();
46641 
46645  static EventDispatcher CreateEventDispatcher(char const * in_name);
46646 
46652  static size_t SelectByShell(ShellKit const & in_shell,
46653  SelectionOptionsKit const & in_options,
46654  SelectionResults & out_results);
46655 
46661  static size_t SelectByShell(ShellKey const & in_shell,
46662  SelectionOptionsKit const & in_options,
46663  SelectionResults & out_results);
46664 
46671  static size_t SelectByVolume(SimpleCuboid const & in_volume,
46672  SelectionOptionsKit const & in_options,
46673  SelectionResults & out_results);
46674 
46681  static size_t SelectByRay(Point const & in_start_point, Vector const & in_direction,
46682  SelectionOptionsKit const & in_options,
46683  SelectionResults & out_results);
46684 
46687  static EventDispatcher const & GetEventDispatcher();
46688 
46689 
46693  static bool GetInformationEventFilter(HPS::Info::Code in_code);
46694 
46698  static bool GetWarningEventFilter(HPS::Info::Code in_code);
46699 
46703  static bool GetErrorEventFilter(HPS::Info::Code in_code);
46704 
46709  static bool SetInformationEventFilter(HPS::Info::Code in_code, bool in_filtered);
46710 
46715  static bool SetWarningEventFilter(HPS::Info::Code in_code, bool in_filtered);
46716 
46721  static bool SetErrorEventFilter(HPS::Info::Code in_code, bool in_filtered);
46722 
46723 
46726  static void SetEmergencyHandler(HPS::EmergencyHandler const & in_emergency_handler);
46727 
46729  static void UnsetEmergencyHandler();
46730 
46733  static size_t GetSoftMemoryLimit();
46734 
46738  static size_t SetSoftMemoryLimit(size_t in_limit_bytes);
46739 
46742  static size_t GetOOCMemoryLimit();
46743 
46747  static size_t SetOOCMemoryLimit(size_t in_limit_bytes);
46748 
46752  static bool IsDriverAvailable(HPS::Window::Driver in_driver);
46753 
46759  static bool ShowAvailableGPUs(HPS::UTF8Array & out_available_gpus);
46760 
46761 private:
46763  Database();
46764 };
46765 
46766 
46770 
46771 
46772 
46774 class HPS_API EventDispatcher : public Object
46775 {
46776 public:
46779  EventDispatcher();
46780 
46783  EventDispatcher(EventDispatcher const & in_that);
46784 
46788  EventDispatcher(EventDispatcher && in_that);
46789 
46793  EventDispatcher & operator=(EventDispatcher && in_that);
46794 
46795  virtual ~EventDispatcher();
46796 
46797  static const HPS::Type staticType = HPS::Type::EventDispatcher;
46798  HPS::Type ObjectType() const {return staticType;};
46799 
46803  EventDispatcher & operator=(EventDispatcher const & in_that);
46804 
46808  bool Equals(EventDispatcher const & in_that) const;
46809 
46813  bool operator==(EventDispatcher const & in_that) const;
46814 
46818  bool operator!=(EventDispatcher const & in_that) const;
46819 
46824  bool Subscribe(EventHandler const & in_handler, intptr_t in_type) const;
46825 
46830  bool UnSubscribe(EventHandler const & in_handler, intptr_t in_type) const;
46831 
46836  bool UnSubscribe(EventHandler const & in_handler) const;
46837 
46841  bool UnSubscribe(intptr_t in_type) const;
46842 
46846  bool InjectEvent(Event const & in_event) const;
46847 
46852  EventNotifier InjectEventWithNotifier(Event const & in_event) const;
46853 
46856  void Shutdown() const;
46857 
46860  bool IsShutdown() const;
46861 
46862 
46865  void SetName(char const * in_name) const;
46866 
46869  void ShowName(UTF8 & out_name) const;
46870 
46871 private:
46873  virtual void Reset() {}
46874 };
46875 
46876 
46879 class HPS_API EventHandler : public Object
46880 {
46881 public:
46883  EventHandler();
46884 
46887  EventHandler(EventHandler const & in_that);
46888 
46892  EventHandler(EventHandler && in_that);
46893 
46897  EventHandler & operator=(EventHandler && in_that);
46898 
46902  EventHandler & operator=(EventHandler const & in_that);
46903 
46904  virtual ~EventHandler();
46905 
46906  static const HPS::Type staticType = HPS::Type::EventHandler;
46907  HPS::Type ObjectType() const {return staticType;};
46908 
46913  bool Subscribe(EventDispatcher const & in_dispatcher, intptr_t in_type) const;
46914 
46919  bool UnSubscribe(EventDispatcher const & in_dispatcher, intptr_t in_type) const;
46920 
46924  bool UnSubscribe(EventDispatcher const & in_dispatcher) const;
46925 
46927  void UnSubscribeEverything() const;
46928 
46930  virtual void Reset() { UnSubscribeEverything(); }
46931 
46934  void Shutdown();
46935 
46938  enum class HandleResult : uint32_t
46939  {
46940  Handled,
46941  NotHandled
46942  };
46943 
46948  virtual HandleResult Handle(Event const * in_event) { HPS_UNREFERENCED(in_event); return HandleResult::NotHandled;};
46949 };
46950 
46951 
46952 
46954 class HPS_API TimerTickEvent : public Event
46955 {
46956 public:
46959  {
46960  channel = GetClassID();
46961  consumable = false;
46962  }
46963 
46964 
46967  TimerTickEvent(Event const & in_event) : Event(in_event)
46968  {
46969  if(in_event.GetChannel() != Object::ClassID<TimerTickEvent>())
46970  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
46971  }
46972 
46973  ~TimerTickEvent();
46974 
46977  Event * Clone() const
46978  {
46979  TimerTickEvent * new_event = new TimerTickEvent(*this);
46980  return new_event;
46981  }
46982 
46986  virtual bool Drop(Event const * in_that_event) const
46987  {
46988  HPS_UNREFERENCED(in_that_event);
46989  return true;
46990  }
46991 
46992  virtual intptr_t Freshen() const {
46993  return GetClassID();
46994  }
46995 };
46996 
46998 class HPS_API HighlightEvent : public Event
46999 {
47000 public:
47001  enum class Action : uint32_t
47002  {
47003  None = 0,
47004  Highlight,
47005  Unhighlight,
47006  };
47007 
47010  {
47011  channel = GetClassID();
47012  consumable = false;
47013  action = Action::None;
47014  }
47015 
47016  HighlightEvent(Action in_action, SelectionResults const & in_results = SelectionResults(), HighlightOptionsKit const & in_options = HighlightOptionsKit())
47017  : Event(), action(in_action), results(in_results), options(in_options)
47018  {
47019  channel = GetClassID();
47020  consumable = false;
47021  }
47022 
47025  HighlightEvent(Event const & in_event) : Event(in_event)
47026  {
47027  if (in_event.GetChannel() == Object::ClassID<HighlightEvent>())
47028  {
47029  auto that = static_cast<HighlightEvent const &>(in_event);
47030  action = that.action;
47031  results = that.results;
47032  options = that.options;
47033  }
47034  else
47035  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
47036  }
47037 
47038  ~HighlightEvent();
47039 
47042  Event * Clone() const
47043  {
47044  HighlightEvent * new_event = new HighlightEvent(*this);
47045  return new_event;
47046  }
47047 
47048  Action action;
47049  SelectionResults results;
47050  HighlightOptionsKit options;
47051 };
47052 
47054 class HPS_API InformationEvent : public Event
47055 {
47056 public:
47058  InformationEvent() : Event(), code(HPS::Info::Code::Unknown) { channel = GetClassID(); }
47059 
47062  InformationEvent(char const * in_message);
47063 
47067  InformationEvent(char const * in_message, HPS::Info::Code in_code);
47068 
47071  InformationEvent(Event const & in_event) : Event(in_event)
47072  {
47073  if (in_event.GetChannel() == Object::ClassID<InformationEvent>())
47074  {
47075  InformationEvent const * event = static_cast<InformationEvent const *>(&in_event);
47076  message = event->message;
47077  code = event->code;
47078  }
47079  else
47080  {
47081  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
47082  }
47083  }
47084 
47085  ~InformationEvent();
47086 
47089  Event * Clone() const
47090  {
47091  InformationEvent * new_event = new InformationEvent(*this);
47092  return new_event;
47093  }
47094 
47098  virtual bool Equals(InformationEvent const & in_that) const
47099  {
47100  return message == in_that.message && code == in_that.code;
47101  }
47102 
47106  virtual bool operator== (InformationEvent const & in_that) const
47107  {
47108  return Equals(in_that);
47109  }
47110 
47114  virtual bool operator!= (InformationEvent const & in_that) const
47115  {
47116  return !Equals(in_that);
47117  }
47118 
47121 };
47122 
47123 
47125 class HPS_API WarningEvent : public Event
47126 {
47127 public:
47129  WarningEvent() : Event(), code(HPS::Info::Code::Unknown) { channel = GetClassID(); }
47130 
47133  WarningEvent(char const * in_message);
47134 
47138  WarningEvent(char const * in_message, HPS::Info::Code in_code);
47139 
47142  WarningEvent(Event const & in_event) : Event(in_event)
47143  {
47144  if(in_event.GetChannel() == Object::ClassID<WarningEvent>())
47145  {
47146  WarningEvent const * event = static_cast<WarningEvent const *>(&in_event);
47147  message = event->message;
47148  code = event->code;
47149  }
47150  else
47151  {
47152  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
47153  }
47154  }
47155 
47156  ~WarningEvent();
47157 
47160  Event * Clone() const
47161  {
47162  WarningEvent * new_event = new WarningEvent(*this);
47163  return new_event;
47164  }
47165 
47169  virtual bool Equals(WarningEvent const & in_that) const
47170  {
47171  return message == in_that.message && code == in_that.code;
47172  }
47173 
47177  virtual bool operator== (WarningEvent const & in_that) const
47178  {
47179  return Equals(in_that);
47180  }
47181 
47185  virtual bool operator!= (WarningEvent const & in_that) const
47186  {
47187  return !Equals(in_that);
47188  }
47189 
47192 };
47193 
47194 
47196 class HPS_API ErrorEvent : public Event
47197 {
47198 public:
47200  ErrorEvent() : Event(), code(HPS::Info::Code::Unknown) { channel = GetClassID(); }
47201 
47204  ErrorEvent(char const * in_message);
47205 
47209  ErrorEvent(char const * in_message, HPS::Info::Code in_code);
47210 
47213  ErrorEvent(Event const & in_event) : Event(in_event)
47214  {
47215  if(in_event.GetChannel() == Object::ClassID<ErrorEvent>())
47216  {
47217  ErrorEvent const * event = static_cast<ErrorEvent const *>(&in_event);
47218  message = event->message;
47219  code = event->code;
47220  }
47221  else
47222  {
47223  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
47224  }
47225  }
47226 
47227  ~ErrorEvent();
47228 
47231  Event * Clone() const
47232  {
47233  ErrorEvent * new_event = new ErrorEvent(*this);
47234  return new_event;
47235  }
47236 
47240  virtual bool Equals(ErrorEvent const & in_that) const
47241  {
47242  return message == in_that.message && code == in_that.code;
47243  }
47244 
47248  virtual bool operator== (ErrorEvent const & in_that) const
47249  {
47250  return Equals(in_that);
47251  }
47252 
47256  virtual bool operator!= (ErrorEvent const & in_that) const
47257  {
47258  return !Equals(in_that);
47259  }
47260 
47263 };
47264 
47265 
47267 class HPS_API StandAloneWindowEvent : public Event
47268 {
47269 public:
47270 
47273  enum class Action : uint32_t
47274  {
47275  Unknown,
47276  Close,
47277  FocusIn,
47278  FocusOut,
47279  };
47280 
47282  StandAloneWindowEvent() : Event(), action(Action::Unknown) { channel = GetClassID(); }
47283 
47284 
47287  StandAloneWindowEvent(Action in_action) : Event(), action(in_action) { channel = GetClassID(); }
47288 
47291  StandAloneWindowEvent(Event const & in_event) : Event(in_event)
47292  {
47293  if(in_event.GetChannel() == Object::ClassID<StandAloneWindowEvent>())
47294  {
47295  StandAloneWindowEvent const * event = static_cast<StandAloneWindowEvent const *>(&in_event);
47296  action = event->action;
47297  }
47298  else
47299  {
47300  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
47301  }
47302  }
47303 
47305 
47308  Event * Clone() const
47309  {
47310  StandAloneWindowEvent * new_event = new StandAloneWindowEvent(*this);
47311  return new_event;
47312  }
47313 
47317  virtual bool Equals(StandAloneWindowEvent const & in_that) const
47318  {
47319  return action == in_that.action;
47320  }
47321 
47325  virtual bool operator== (StandAloneWindowEvent const & in_that) const
47326  {
47327  return Equals(in_that);
47328  }
47329 
47333  virtual bool operator!= (StandAloneWindowEvent const & in_that) const
47334  {
47335  return !Equals(in_that);
47336  }
47337 
47339 };
47340 
47342 class HPS_API FocusLostEvent : public Event
47343 {
47344 public:
47347  Event()
47348  { channel = GetClassID(); }
47349 
47350  ~FocusLostEvent();
47351 
47354  Event * Clone() const
47355  {
47356  FocusLostEvent * new_event = new FocusLostEvent(*this);
47357  return new_event;
47358  }
47359 };
47360 
47362 class HPS_API TextInputEvent : public Event
47363 {
47364  public:
47367  Event()
47368  { channel = GetClassID(); }
47369 
47372  TextInputEvent(char const * in_text) : Event(), text(in_text, "utf8") { channel = GetClassID(); }
47373 
47376  TextInputEvent(Event const & in_event) : Event(in_event)
47377  {
47378  if(in_event.GetChannel() == Object::ClassID<TextInputEvent>())
47379  {
47380  TextInputEvent const * event = static_cast<TextInputEvent const *>(&in_event);
47381  text = event->text;
47382  }
47383  else
47384  {
47385  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
47386  }
47387  }
47388 
47392  virtual bool Equals(TextInputEvent const & in_that) const
47393  {
47394  return text == in_that.text;
47395  }
47396 
47400  virtual bool operator== (TextInputEvent const & in_that) const
47401  {
47402  return Equals(in_that);
47403  }
47404 
47408  virtual bool operator!= (ErrorEvent const & in_that) const
47409  {
47410  return !Equals(in_that);
47411  }
47412 
47413  ~TextInputEvent();
47414 
47417  Event * Clone() const
47418  {
47419  TextInputEvent * new_event = new TextInputEvent(*this);
47420  return new_event;
47421  }
47422 
47424 };
47425 
47426 
47428 class HPS_API UpdateCompletedEvent : public Event
47429 {
47430 public:
47432  UpdateCompletedEvent() : Event(), update_time(-1) { channel = GetClassID(); }
47433 
47435  UpdateCompletedEvent(Time in_update_time, Window::UpdateStatus in_update_status) : Event(), update_time(in_update_time), update_status(in_update_status) { channel = GetClassID(); }
47436 
47439  UpdateCompletedEvent(Event const & in_event) : Event(in_event)
47440  {
47441  if(in_event.GetChannel() == Object::ClassID<UpdateCompletedEvent>())
47442  {
47443  UpdateCompletedEvent const * event = static_cast<UpdateCompletedEvent const *>(&in_event);
47444  update_time = event->update_time;
47445  update_status = event->update_status;
47446  }
47447  else
47448  {
47449  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
47450  }
47451  }
47452 
47453  virtual ~UpdateCompletedEvent();
47454 
47457  Event * Clone() const
47458  {
47459  UpdateCompletedEvent * new_event = new UpdateCompletedEvent(*this);
47460  return new_event;
47461  }
47462 
47463  Time update_time;
47464  Window::UpdateStatus update_status;
47465 };
47466 
47468 class HPS_API ImportStatusEvent : public Event
47469 {
47470 public:
47473  : Event()
47474  { channel = GetClassID(); }
47475 
47476  ImportStatusEvent(char const * in_message)
47477  : Event()
47478  , import_status_message(in_message, "utf8")
47479  { channel = GetClassID(); }
47480 
47483  ImportStatusEvent(Event const & in_event) : Event(in_event)
47484  {
47485  if (in_event.GetChannel() == Object::ClassID<ImportStatusEvent>())
47486  {
47487  auto event = static_cast<ImportStatusEvent const &>(in_event);
47488  import_status_message = event.import_status_message;
47489  }
47490  else
47491  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
47492  }
47493 
47494  ~ImportStatusEvent();
47495 
47498  Event * Clone() const
47499  {
47500  ImportStatusEvent * new_event = new ImportStatusEvent(*this);
47501  return new_event;
47502  }
47503 
47504  HPS::UTF8 import_status_message;
47505 };
47506 
47508 class HPS_API ShowKeyboardEvent : public Event
47509 {
47510 public:
47513  : Event()
47514  { channel = GetClassID(); }
47515 
47518  ShowKeyboardEvent(Event const & in_event) : Event(in_event)
47519  {
47520  if (in_event.GetChannel() != Object::ClassID<ShowKeyboardEvent>())
47521  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
47522  }
47523 
47524  ~ShowKeyboardEvent();
47525 
47528  Event * Clone() const
47529  {
47530  ShowKeyboardEvent * new_event = new ShowKeyboardEvent(*this);
47531  return new_event;
47532  }
47533 
47534 };
47535 
47537 class HPS_API HideKeyboardEvent : public Event
47538 {
47539 public:
47542  : Event()
47543  { channel = GetClassID(); }
47544 
47547  HideKeyboardEvent(Event const & in_event) : Event(in_event)
47548  {
47549  if (in_event.GetChannel() != Object::ClassID<HideKeyboardEvent>())
47550  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
47551  }
47552 
47553  ~HideKeyboardEvent();
47554 
47557  Event * Clone() const
47558  {
47559  HideKeyboardEvent * new_event = new HideKeyboardEvent(*this);
47560  return new_event;
47561  }
47562 
47563 };
47564 
47566 class HPS_API ModifierKeys
47567 {
47568 public:
47570  ModifierKeys() : modifiers(_key_none) {}
47571 
47575  bool Equals(ModifierKeys const & in_that) const
47576  {
47577  return modifiers == in_that.modifiers;
47578  }
47579 
47583  bool operator== (ModifierKeys const & in_that) const
47584  {
47585  return Equals(in_that);
47586  }
47587 
47591  bool operator!= (ModifierKeys const & in_that) const
47592  {
47593  return !Equals(in_that);
47594  }
47595 
47598  bool None() const { return modifiers == _key_none; }
47599 
47602  bool Shift() const { return (modifiers & _key_shift) != 0; }
47603 
47606  bool Control() const { return (modifiers & _key_control) != 0; }
47607 
47610  bool Alt() const { return (modifiers & _key_alt) != 0; }
47611 
47614  bool Meta() const { return (modifiers & _key_meta) != 0; }
47615 
47618  bool CapsLock() const {return (modifiers & _key_caps_lock) != 0; }
47619 
47622  bool NumLock() const {return (modifiers & _key_num_lock) != 0; }
47623 
47626  bool ScrollLock() const {return (modifiers & _key_scroll_lock) != 0; }
47627 
47630  bool RightShift() const {return (modifiers & _key_right_shift) != 0; }
47631 
47634  bool LeftShift() const {return (modifiers & _key_left_shift) != 0; }
47635 
47638  bool RightControl() const {return (modifiers & _key_right_control) != 0; }
47639 
47642  bool LeftControl() const {return (modifiers & _key_left_control) != 0; }
47643 
47646  bool RightAlt() const {return (modifiers & _key_right_alt) != 0; }
47647 
47650  bool LeftAlt() const {return (modifiers & _key_left_alt) != 0; }
47651 
47654  bool RightMeta() const {return (modifiers & _key_right_meta) != 0; }
47655 
47658  bool LeftMeta() const {return (modifiers & _key_left_meta) != 0; }
47659 
47663  bool HasAll(ModifierKeys const & in_keys) const { return (modifiers & in_keys.modifiers) == in_keys.modifiers; }
47664 
47668  bool HasAny(ModifierKeys const & in_keys) const { return (modifiers & in_keys.modifiers) != 0; }
47669 
47670 
47673  void Shift(bool in_state) { if(in_state) modifiers |= _key_shift; else modifiers &= ~(_key_shift); }
47674 
47677  void Control(bool in_state) { if(in_state) modifiers |= _key_control; else modifiers &= ~(_key_control); }
47678 
47681  void Alt(bool in_state) { if(in_state) modifiers |= _key_alt; else modifiers &= ~(_key_alt); }
47682 
47685  void Meta(bool in_state) { if(in_state) modifiers |= _key_meta; else modifiers &= ~(_key_meta); }
47686 
47689  void CapsLock(bool in_state) { if (in_state) modifiers |= _key_caps_lock; else modifiers &= ~(_key_caps_lock); }
47690 
47693  void NumLock(bool in_state) { if (in_state) modifiers |= _key_num_lock; else modifiers &= ~(_key_num_lock); }
47694 
47697  void ScrollLock(bool in_state) { if (in_state) modifiers |= _key_scroll_lock; else modifiers &= ~(_key_scroll_lock); }
47698 
47701  void RightShift(bool in_state) { if (in_state) modifiers |= _key_right_shift; else modifiers &= ~(_key_right_shift); }
47702 
47705  void LeftShift(bool in_state) { if (in_state) modifiers |= _key_left_shift; else modifiers &= ~(_key_left_shift); }
47706 
47709  void RightControl(bool in_state) { if (in_state) modifiers |= _key_right_control; else modifiers &= ~(_key_right_control); }
47710 
47713  void LeftControl(bool in_state) { if (in_state) modifiers |= _key_left_control; else modifiers &= ~(_key_left_control); }
47714 
47717  void RightAlt(bool in_state) { if (in_state) modifiers |= _key_right_alt; else modifiers &= ~(_key_right_alt); }
47718 
47721  void LeftAlt(bool in_state) { if (in_state) modifiers |= _key_left_alt; else modifiers &= ~(_key_left_alt); }
47722 
47725  void RightMeta(bool in_state) { if (in_state) modifiers |= _key_right_meta; else modifiers &= ~(_key_right_meta); }
47726 
47729  void LeftMeta(bool in_state) { if (in_state) modifiers |= _key_left_meta; else modifiers &= ~(_key_left_meta); }
47730 
47734  ModifierKeys operator+ (ModifierKeys const & in_modifiers_to_merge)
47735  {
47736  ModifierKeys ret;
47737  ret.modifiers = modifiers | in_modifiers_to_merge.modifiers;
47738  return ret;
47739  }
47740 
47744  ModifierKeys operator- (ModifierKeys const & in_modifiers_to_remove)
47745  {
47746  ModifierKeys ret;
47747  ret.modifiers = modifiers & ~in_modifiers_to_remove.modifiers;
47748  return ret;
47749  }
47750 
47754  ModifierKeys & operator+= (ModifierKeys const & in_modifiers_to_merge) { *this = *this + in_modifiers_to_merge; return *this; }
47755 
47759  ModifierKeys & operator-= (ModifierKeys const & in_modifiers_to_remove) { *this = *this - in_modifiers_to_remove; return *this; }
47760 
47761 
47765  static ModifierKeys KeyShift() { ModifierKeys ret; ret.Shift(true); return ret; }
47766 
47770  static ModifierKeys KeyControl() { ModifierKeys ret; ret.Control(true); return ret; }
47771 
47775  static ModifierKeys KeyAlt() { ModifierKeys ret; ret.Alt(true); return ret; }
47776 
47780  static ModifierKeys KeyMeta() { ModifierKeys ret; ret.Meta(true); return ret; }
47781 
47784  static ModifierKeys KeyCapsLock() { ModifierKeys ret; ret.CapsLock(true); return ret; }
47785 
47788  static ModifierKeys KeyNumLock() { ModifierKeys ret; ret.NumLock(true); return ret; }
47789 
47792  static ModifierKeys KeyScrollLock() { ModifierKeys ret; ret.ScrollLock(true); return ret; }
47793 
47796  static ModifierKeys KeyRightShift() { ModifierKeys ret; ret.RightShift(true); return ret; }
47797 
47800  static ModifierKeys KeyLeftShift() { ModifierKeys ret; ret.LeftShift(true); return ret; }
47801 
47804  static ModifierKeys KeyRightControl() { ModifierKeys ret; ret.RightControl(true); return ret; }
47805 
47808  static ModifierKeys KeyLeftControl() { ModifierKeys ret; ret.LeftControl(true); return ret; }
47809 
47812  static ModifierKeys KeyRightAlt() { ModifierKeys ret; ret.RightAlt(true); return ret; }
47813 
47816  static ModifierKeys KeyLeftAlt() { ModifierKeys ret; ret.LeftAlt(true); return ret; }
47817 
47820  static ModifierKeys KeyRightMeta() { ModifierKeys ret; ret.RightMeta(true); return ret; }
47821 
47824  static ModifierKeys KeyLeftMeta() { ModifierKeys ret; ret.LeftMeta(true); return ret; }
47825 
47826 protected:
47827 
47831  {
47832  _key_none = 0x0000,
47833  _key_caps_lock = 0x0001,
47834  _key_num_lock = 0x0002,
47835  _key_scroll_lock = 0x0004,
47836  _key_right_shift = 0x0008,
47837  _key_left_shift = 0x0010,
47838  _key_right_control = 0x0020,
47839  _key_left_control = 0x0040,
47840  _key_right_alt = 0x0080,
47841  _key_left_alt = 0x0100,
47842  _key_right_meta = 0x0200,
47843  _key_left_meta = 0x0400,
47844  _key_shift = _key_left_shift | _key_right_shift,
47845  _key_control = _key_left_control | _key_right_control,
47846  _key_alt = _key_left_alt | _key_right_alt,
47847  _key_meta = _key_left_meta | _key_right_meta,
47848  };
47849 
47850  int modifiers;
47851 };
47852 
47853 
47856 class HPS_API InputEvent : public Event
47857 {
47858 public:
47859 
47861  InputEvent() : Event() { channel = GetClassID(); }
47862 
47865  InputEvent(ModifierKeys const & in_modifiers) : Event(), ModifierKeyState(in_modifiers) { channel = GetClassID(); }
47866 
47867  ~InputEvent();
47868 
47871  Event * Clone() const
47872  {
47873  InputEvent * new_event = new InputEvent(*this);
47874  return new_event;
47875  }
47876 
47880  virtual bool Equals(InputEvent const & in_that) const
47881  {
47882  if ( GetClassID() == in_that.GetClassID())
47883  return ModifierKeyState == in_that.ModifierKeyState;
47884  return false;
47885  }
47886 
47890  virtual bool operator== (InputEvent const & in_that) const
47891  {
47892  return Equals(in_that);
47893  }
47894 
47898  virtual bool operator!= (InputEvent const & in_that) const
47899  {
47900  return !Equals(in_that);
47901  }
47902 
47906  {
47907  return ModifierKeyState;
47908  }
47909 
47911 };
47912 
47914 class HPS_API TouchEvent : public InputEvent
47915 {
47916 public:
47919  enum class Action : uint32_t
47920  {
47921  TouchDown,
47922  TouchUp,
47923  Move,
47924  };
47925 
47927  TouchEvent() : InputEvent() { channel = GetClassID(); }
47928 
47933  TouchEvent(Action in_action, ModifierKeys in_modifier = ModifierKeys())
47934  : InputEvent(in_modifier), CurrentAction(in_action) { channel = GetClassID(); }
47935 
47941  TouchEvent(Action in_action, TouchArray const & in_touches, ModifierKeys in_modifier = ModifierKeys())
47942  : InputEvent(in_modifier), CurrentAction(in_action), Touches(in_touches) { channel = GetClassID(); }
47943 
47950  TouchEvent(Action in_action, size_t in_touch_count, Touch const in_touches[], ModifierKeys in_modifier = ModifierKeys())
47951  : InputEvent(in_modifier), CurrentAction(in_action), Touches(in_touches, in_touches + in_touch_count) { channel = GetClassID(); }
47952 
47953 
47956  TouchEvent(Event const & in_event) : InputEvent()
47957  {
47958  if(in_event.GetChannel() == Object::ClassID<TouchEvent>())
47959  {
47960  TouchEvent const * event = static_cast<TouchEvent const *>(&in_event);
47961  channel = GetClassID();
47962  CurrentAction = event->CurrentAction;
47963  Touches = event->Touches;
47964  ModifierKeyState = event->ModifierKeyState;
47965  }
47966  else
47967  throw HPS::InvalidSpecificationException("Invalid Event type to cast from.");
47968  }
47969 
47970  ~TouchEvent();
47971 
47972 
47975  Event * Clone() const
47976  {
47977  TouchEvent * new_event = new TouchEvent(*this);
47978  return new_event;
47979  }
47980 
47984  virtual bool Equals(InputEvent const & in_that) const
47985  {
47986  if (GetClassID() == in_that.GetClassID())
47987  return Equals(static_cast<TouchEvent>(in_that));
47988  return false;
47989  }
47990 
47994  bool Equals(TouchEvent const & in_that) const
47995  {
47996  return InputEvent::Equals(in_that) && Touches == in_that.Touches && CurrentAction == in_that.CurrentAction;
47997  }
47998 
48002  virtual bool operator== (TouchEvent const & in_that) const
48003  {
48004  return Equals(in_that);
48005  }
48006 
48010  virtual bool operator!= (TouchEvent const & in_that) const
48011  {
48012  return !Equals(in_that);
48013  }
48014 
48018  virtual bool Drop(Event const * in_that_event) const
48019  {
48020  HPS::TouchEvent const * that_touch_event = static_cast<HPS::TouchEvent const *>(in_that_event);
48021 
48022  if (CurrentAction == that_touch_event->CurrentAction && CurrentAction == Action::Move
48023  && Touches.size() == that_touch_event->Touches.size() )
48024  {
48025  TouchArray these_touches = Touches;
48026  TouchArray those_touches = that_touch_event->Touches;
48027 
48028  std::sort(those_touches.begin(), those_touches.end(), sort_predicate);
48029  std::sort(these_touches.begin(), these_touches.end(), sort_predicate);
48030 
48031  for (size_t i = 0 ; i < these_touches.size() ; i++)
48032  {
48033  if (these_touches[i].ID != those_touches[i].ID)
48034  return false;
48035  }
48036  return true;
48037  }
48038 
48039  return false;
48040  }
48041 
48044 
48045 private:
48051  static bool sort_predicate(Touch const & in_a, Touch const & in_b)
48052  {
48053  return static_cast<int>(in_a.ID) < static_cast<int>(in_b.ID);
48054  }
48055 };
48056 
48057 
48059 class HPS_API MouseButtons
48060 {
48061 public:
48063  MouseButtons() : buttons(_button_none) {}
48064 
48068  bool Equals(MouseButtons const & in_that) const
48069  {
48070  return buttons == in_that.buttons;
48071  }
48072 
48076  bool operator== (MouseButtons const & in_that) const
48077  {
48078  return Equals(in_that);
48079  }
48080 
48084  bool operator!= (MouseButtons const & in_that) const
48085  {
48086  return !Equals(in_that);
48087  }
48088 
48091  bool None() const { return buttons == _button_none; }
48092 
48095  bool Left() const { return (buttons & _button_left) != 0; }
48096 
48099  bool Right() const { return (buttons & _button_right) != 0; }
48100 
48103  bool Middle() const { return (buttons & _button_middle) != 0; }
48104 
48107  bool X1() const { return (buttons & _button_x1) != 0; }
48108 
48111  bool X2() const { return (buttons & _button_x2) != 0; }
48112 
48113 
48117  bool HasAll(MouseButtons const & in_buttons) const { return (buttons & in_buttons.buttons) == in_buttons.buttons; }
48118 
48122  bool HasAny(MouseButtons const & in_buttons) const { return (buttons & in_buttons.buttons) != 0; }
48123 
48126  void Left(bool in_state) { if(in_state) buttons |= _button_left; else buttons &= ~(_button_left); }
48127 
48130  void Right(bool in_state) { if(in_state) buttons |= _button_right; else buttons &= ~(_button_right); }
48131 
48134  void Middle(bool in_state) { if(in_state) buttons |= _button_middle; else buttons &= ~(_button_middle); }
48135 
48138  void X1(bool in_state) { if(in_state) buttons |= _button_x1; else buttons &= ~(_button_x1); }
48139 
48142  void X2(bool in_state) { if(in_state) buttons |= _button_x2; else buttons &= ~(_button_x2); }
48143 
48147  MouseButtons operator+ (MouseButtons const & in_buttons_to_merge)
48148  {
48149  MouseButtons ret;
48150  ret.buttons = buttons | in_buttons_to_merge.buttons;
48151  return ret;
48152  }
48153 
48157  MouseButtons operator- (MouseButtons const & in_buttons_to_remove)
48158  {
48159  MouseButtons ret;
48160  ret.buttons = buttons & ~in_buttons_to_remove.buttons;
48161  return ret;
48162  }
48163 
48167  MouseButtons & operator+= (MouseButtons const & in_buttons_to_merge) { *this = *this + in_buttons_to_merge; return *this; }
48168 
48172  MouseButtons & operator-= (MouseButtons const & in_buttons_to_remove) { *this = *this - in_buttons_to_remove; return *this; }
48173 
48174 
48177  static MouseButtons ButtonLeft() { MouseButtons ret; ret.Left(true); return ret; }
48178 
48181  static MouseButtons ButtonRight() { MouseButtons ret; ret.Right(true); return ret; }
48182 
48185  static MouseButtons ButtonMiddle() { MouseButtons ret; ret.Middle(true); return ret; }
48186 
48189  static MouseButtons ButtonX1() { MouseButtons ret; ret.X1(true); return ret; }
48190 
48193  static MouseButtons ButtonX2() { MouseButtons ret; ret.X2(true); return ret; }
48194 
48195 protected:
48196 
48199  enum Buttons
48200  {
48201  _button_none = 0x0000,
48202  _button_left = 0x0001,
48203  _button_right = 0x0002,
48204  _button_middle = 0x0004,
48205  _button_x1 = 0x0008,
48206  _button_x2 = 0x0010
48207  };
48208 
48209  int buttons;
48210 };
48211 
48213 class HPS_API MouseEvent : public InputEvent
48214 {
48215 public:
48216 
48219  enum class Action : uint32_t
48220  {
48221  ButtonUp,
48222  ButtonDown,
48223  Move,
48224  Scroll,
48225  Enter,
48226  Leave
48227  };
48228 
48230  MouseEvent() : InputEvent() { channel = GetClassID(); }
48231 
48238  MouseEvent(Action in_action, WindowPoint in_location, MouseButtons in_button = MouseButtons(), ModifierKeys in_modifier = ModifierKeys(), size_t in_click_count = 0)
48239  : InputEvent(in_modifier), CurrentAction(in_action), Location(in_location), CurrentButton(in_button), WheelDelta(0), ClickCount(in_click_count) { channel = GetClassID(); }
48240 
48248  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)
48249  : InputEvent(in_modifier), CurrentAction(in_action), Location(in_location), WheelDelta(in_wheel_delta), ClickCount(in_click_count) { channel = GetClassID(); }
48250 
48253  MouseEvent(Event const & in_event) : InputEvent()
48254  {
48255  if(in_event.GetChannel() == Object::ClassID<MouseEvent>())
48256  {
48257  MouseEvent const * event = static_cast<MouseEvent const *>(&in_event);
48258  channel = GetClassID();
48259  CurrentAction = event->CurrentAction;
48260  Location = event->Location;
48261  CurrentButton = event->CurrentButton;
48262  WheelDelta = event->WheelDelta;
48263  ClickCount = event->ClickCount;
48264  }
48265  else
48266  {
48267  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
48268  }
48269  }
48270 
48271  ~MouseEvent();
48272 
48275  Event * Clone() const
48276  {
48277  MouseEvent * new_event = new MouseEvent(*this);
48278  return new_event;
48279  }
48280 
48284  virtual bool Equals(InputEvent const & in_that) const
48285  {
48286  if (GetClassID() == in_that.GetClassID())
48287  return Equals(static_cast<MouseEvent>(in_that));
48288  return false;
48289  }
48290 
48294  virtual bool Equals(MouseEvent const & in_that) const
48295  {
48296  return InputEvent::Equals(in_that) && CurrentAction == in_that.CurrentAction
48297  && CurrentButton == in_that.CurrentButton && WheelDelta == in_that.WheelDelta
48298  && Location == in_that.Location && ClickCount == in_that.ClickCount;
48299  }
48300 
48304  virtual bool operator== (MouseEvent const & in_that) const
48305  {
48306  return Equals(in_that);
48307  }
48308 
48312  virtual bool operator!= (MouseEvent const & in_that) const
48313  {
48314  return !Equals(in_that);
48315  }
48316 
48320  virtual bool Drop(Event const * in_that_event) const
48321  {
48322  HPS::MouseEvent const * that_mouse_event = static_cast<HPS::MouseEvent const *>(in_that_event);
48323 
48324  if (CurrentAction == that_mouse_event->CurrentAction &&
48325  (CurrentAction == Action::ButtonDown || CurrentAction == Action::ButtonUp || CurrentAction == Action::Move) &&
48326  CurrentButton == that_mouse_event->CurrentButton)
48327  return true;
48328 
48329  return false;
48330  }
48331 
48332  virtual intptr_t Freshen() const {
48333 
48334  if (CurrentAction == Action::Move)
48335  return GetClassID();
48336 
48337  return 0;
48338  }
48339 
48343  float WheelDelta;
48344  size_t ClickCount;
48345 };
48346 
48347 
48349 class HPS_API KeyboardEvent : public InputEvent
48350 {
48351 public:
48354  enum class Action : uint32_t
48355  {
48356  None,
48357  KeyDown,
48358  KeyUp
48359  };
48360 
48362  KeyboardEvent() : InputEvent(), CurrentAction(Action::None) { channel = GetClassID(); }
48363 
48368  : InputEvent(in_modifiers), CurrentAction(in_action) { channel = GetClassID(); }
48369 
48375  KeyboardEvent(KeyboardEvent::Action in_action, size_t in_keyboardcode_count, HPS::KeyboardCode const in_keyboardcodes[], ModifierKeys in_modifiers = ModifierKeys())
48376  : InputEvent(in_modifiers), CurrentAction(in_action)
48377  {
48378  channel = GetClassID();
48379  KeyboardCodes.assign(in_keyboardcodes, in_keyboardcodes + in_keyboardcode_count);
48380  }
48381 
48386  KeyboardEvent(KeyboardEvent::Action in_action, KeyboardCodeArray const & in_keyboardcodes, ModifierKeys in_modifiers = ModifierKeys())
48387  : InputEvent(in_modifiers), CurrentAction(in_action)
48388  {
48389  channel = GetClassID();
48390  KeyboardCodes = in_keyboardcodes;
48391  }
48392 
48395  KeyboardEvent(Event const & in_event) : InputEvent()
48396  {
48397  if(in_event.GetChannel() == Object::ClassID<KeyboardEvent>())
48398  {
48399  KeyboardEvent const * event = static_cast<KeyboardEvent const *>(&in_event);
48400  channel = GetClassID();
48401  KeyboardCodes = event->KeyboardCodes;
48402  CurrentAction = event->CurrentAction;
48403  }
48404  else
48405  {
48406  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
48407  }
48408  }
48409 
48410  ~KeyboardEvent();
48411 
48414  Event * Clone() const
48415  {
48416  KeyboardEvent * new_event = new KeyboardEvent(*this);
48417  return new_event;
48418  }
48419 
48423  virtual bool Equals(InputEvent const & in_that) const
48424  {
48425  if (GetClassID() == in_that.GetClassID())
48426  return Equals(static_cast<KeyboardEvent>(in_that));
48427  return false;
48428  }
48429 
48433  virtual bool Equals(KeyboardEvent const & in_that) const
48434  {
48435  return InputEvent::Equals(in_that) && CurrentAction == in_that.CurrentAction && KeyboardCodes == in_that.KeyboardCodes;
48436  }
48437 
48441  virtual bool operator== (KeyboardEvent const & in_that) const
48442  {
48443  return Equals(in_that);
48444  }
48445 
48449  virtual bool operator!= (KeyboardEvent const & in_that) const
48450  {
48451  return !Equals(in_that);
48452  }
48453 
48457  void SetKeyboardCodes(size_t in_keyboardcode_count, HPS::KeyboardCode const in_keyboardcodes[])
48458  {
48459  KeyboardCodes.assign(in_keyboardcodes, in_keyboardcodes + in_keyboardcode_count);
48460  }
48461 
48464  void SetKeyboardCodes(HPS::KeyboardCodeArray const & in_keyboardcodes)
48465  {
48466  KeyboardCodes = in_keyboardcodes;
48467  }
48468 
48471 };
48472 
48473 
48475 class HPS_API MouseState : public Object
48476 {
48477 public:
48479  MouseState();
48480 
48483  MouseState(MouseState const & in_that);
48484 
48488  MouseState(MouseState && in_that);
48489 
48493  MouseState & operator=(MouseState && in_that);
48494 
48495  ~MouseState();
48496 
48497  static const HPS::Type staticType = HPS::Type::MouseState;
48498  HPS::Type ObjectType() const {return staticType;};
48499 
48502  void Assign(MouseState const & in_that);
48503 
48507  MouseState & operator=(MouseState const & in_that);
48508 
48512  bool Equals(MouseState const & in_that) const;
48513 
48517  bool operator== (MouseState const & in_that) const;
48518 
48522  bool operator!= (MouseState const & in_that) const;
48523 
48528  bool HasAll(MouseButtons in_mouse_trigger, ModifierKeys in_modifier_trigger) const;
48529 
48536  void Set(KeyArray const & in_path, MouseEvent const & in_event, WindowPoint const & in_point, MouseButtons in_buttons = MouseButtons(), ModifierKeys in_modifiers = ModifierKeys());
48537 
48540  HPS::MouseEvent GetActiveEvent() const;
48541 
48545  HPS::WindowKey GetEventSource() const;
48546 
48550  HPS::KeyArray GetEventPath() const;
48551 
48554  MouseButtons GetButtons() const;
48555 
48558  WindowPoint GetLocation() const;
48559 
48562  ModifierKeys GetModifierKeys() const;
48563 
48566  void SetActiveEvent(MouseEvent const & in_event);
48567 
48570  void SetEventPath(KeyArray const & in_path);
48571 
48574  void SetButtons(MouseButtons in_buttons);
48575 
48578  void SetLocation(WindowPoint const & in_point);
48579 
48582  void SetModifierKeys(ModifierKeys in_modifiers);
48583 };
48584 
48585 
48586 
48588 class HPS_API TouchState : public Object
48589 {
48590 public:
48592  TouchState();
48593 
48596  TouchState(TouchState const & in_that);
48597 
48601  TouchState(TouchState && in_that);
48602 
48606  TouchState & operator=(TouchState && in_that);
48607 
48608  ~TouchState();
48609 
48610  static const HPS::Type staticType = HPS::Type::TouchState;
48611  HPS::Type ObjectType() const {return staticType;};
48612 
48615  void Assign(TouchState const & in_that);
48616 
48620  TouchState & operator=(TouchState const & in_that);
48621 
48625  bool Equals(TouchState const & in_that) const;
48626 
48630  bool operator== (TouchState const & in_that) const;
48631 
48635  bool operator!= (TouchState const & in_that) const;
48636 
48642  void Set(KeyArray const & in_path, TouchEvent const & in_event, TouchArray const & in_touches, ModifierKeys in_modifiers = ModifierKeys());
48643 
48646  HPS::TouchEvent GetActiveEvent() const;
48647 
48651  HPS::WindowKey GetEventSource() const;
48652 
48656  HPS::KeyArray GetEventPath() const;
48657 
48660  size_t GetTouchCount() const;
48661 
48664  HPS::TouchArray GetTouches() const;
48665 
48668  ModifierKeys GetModifierKeys() const;
48669 
48672  void SetActiveEvent(TouchEvent const & in_event);
48673 
48676  void SetEventPath(KeyArray const & in_path);
48677 
48680  void SetTouches(TouchArray const & in_touches);
48681 
48684  void SetModifierKeys(ModifierKeys in_modifiers);
48685 };
48686 
48687 
48688 
48690 class HPS_API KeyboardState : public Object
48691 {
48692 public:
48694  KeyboardState();
48695 
48698  KeyboardState(KeyboardState const & in_that);
48699 
48703  KeyboardState(KeyboardState && in_that);
48704 
48708  KeyboardState & operator=(KeyboardState && in_that);
48709 
48710  ~KeyboardState();
48711 
48712  static const HPS::Type staticType = HPS::Type::KeyboardState;
48713  HPS::Type ObjectType() const {return staticType;};
48714 
48717  void Assign(KeyboardState const & in_that);
48718 
48722  KeyboardState & operator=(KeyboardState const & in_that);
48723 
48727  bool Equals(KeyboardState const & in_that) const;
48728 
48732  bool operator== (KeyboardState const & in_that) const;
48733 
48737  bool operator!= (KeyboardState const & in_that) const;
48738 
48744  void Set(KeyArray const & in_path, KeyboardEvent const & in_event, KeyboardCodeArray const & in_keyboard_codes, ModifierKeys in_modifiers = ModifierKeys());
48745 
48748  HPS::KeyboardEvent GetActiveEvent() const;
48749 
48753  HPS::WindowKey GetEventSource() const;
48754 
48758  HPS::KeyArray GetEventPath() const;
48759 
48762  size_t GetKeyboardCodeCount() const;
48763 
48766  HPS::KeyboardCodeArray GetKeyboardCodes() const;
48767 
48771  bool GetKeyState(HPS::KeyboardCode in_key_code) const;
48772 
48775  ModifierKeys GetModifierKeys() const;
48776 
48779  void SetActiveEvent(KeyboardEvent const & in_event);
48780 
48783  void SetEventPath(KeyArray const & in_path);
48784 
48787  void SetKeyboardCodes(KeyboardCodeArray const & in_keyboard_codes);
48788 
48791  void SetModifierKeys(ModifierKeys in_modifiers);
48792 };
48793 
48794 
48797 class HPS_API IONotifier : public Object
48798 {
48799 public:
48801  IONotifier();
48802 
48805  IONotifier(IONotifier const & in_that);
48806 
48810  IONotifier(IONotifier && in_that);
48811 
48815  IONotifier & operator=(IONotifier && in_that);
48816 
48817  virtual ~IONotifier();
48818 
48819  static const HPS::Type staticType = HPS::Type::IONotifier;
48820  HPS::Type ObjectType() const {return staticType;};
48821 
48825  IONotifier & operator=(IONotifier const & in_that);
48826 
48829  void Assign(IONotifier const & in_that);
48830 
48833  IONotifier & Wait();
48834 
48837  IOResult Status() const;
48838 
48842  IOResult Status(float & out_percent_complete) const;
48843 
48848  IONotifier & Cancel();
48849 };
48850 
48854 
48856 class HPS_API PointCloud
48857 {
48858 public:
48860 class HPS_API ImportResultsKit : public Kit
48861  {
48862  public:
48864  ImportResultsKit();
48865 
48868  ImportResultsKit(ImportResultsKit const & in_kit);
48869 
48873  ImportResultsKit(ImportResultsKit && in_that);
48874 
48878  ImportResultsKit & operator=(ImportResultsKit && in_that);
48879 
48880  virtual ~ImportResultsKit();
48881 
48882  static const HPS::Type staticType = HPS::Type::PointCloudImportResultsKit;
48883  HPS::Type ObjectType() const { return staticType; };
48884 
48887  void Set(ImportResultsKit const & in_kit);
48888 
48891  void Show(ImportResultsKit & out_kit) const;
48892 
48896  ImportResultsKit & operator=(ImportResultsKit const & in_kit);
48897 
48900  bool Empty() const;
48901 
48905  bool Equals(ImportResultsKit const & in_kit) const;
48906 
48910  bool operator==(ImportResultsKit const & in_kit) const;
48911 
48915  bool operator!=(ImportResultsKit const & in_kit) const;
48916 
48921  ImportResultsKit & SetSegment(SegmentKey const & in_segment);
48922 
48926  ImportResultsKit & UnsetSegment();
48927 
48932  bool ShowSegment(SegmentKey & out_segment) const;
48933 
48936  ImportResultsKit & UnsetEverything();
48937  };
48938 
48940  class HPS_API ImportOptionsKit : public Kit
48941  {
48942  public:
48944  ImportOptionsKit();
48945 
48948  ImportOptionsKit(ImportOptionsKit const & in_kit);
48949 
48953  ImportOptionsKit(ImportOptionsKit && in_that);
48954 
48958  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
48959 
48960  virtual ~ImportOptionsKit();
48961 
48962  static const HPS::Type staticType = HPS::Type::PointCloudImportOptionsKit;
48963  HPS::Type ObjectType() const { return staticType; };
48964 
48967  void Set(ImportOptionsKit const & in_kit);
48968 
48971  void Show(ImportOptionsKit & out_kit) const;
48972 
48976  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
48977 
48980  bool Empty() const;
48981 
48985  bool Equals(ImportOptionsKit const & in_kit) const;
48986 
48990  bool operator==(ImportOptionsKit const & in_kit) const;
48991 
48995  bool operator!=(ImportOptionsKit const & in_kit) const;
48996 
49001  ImportOptionsKit & SetSegment(SegmentKey const & in_segment);
49002 
49005  ImportOptionsKit & UnsetSegment();
49006 
49010  bool ShowSegment(SegmentKey & out_segment) const;
49011 
49018  ImportOptionsKit & SetPointColor(RGBColor const & in_color, bool in_override = false);
49019 
49022  ImportOptionsKit & UnsetPointColor();
49023 
49028  bool ShowPointColor(RGBColor & out_color, bool & out_override) const;
49029 
49032  ImportOptionsKit & UnsetEverything();
49033  };
49034 
49035 
49038  class HPS_API ImportNotifier : public IONotifier
49039  {
49040  public:
49042  ImportNotifier();
49043 
49046  ImportNotifier(ImportNotifier const & in_that);
49047 
49052  ImportNotifier(IONotifier const & in_that);
49053 
49057  ImportNotifier(ImportNotifier && in_that);
49058 
49062  ImportNotifier & operator=(ImportNotifier && in_that);
49063 
49064  virtual ~ImportNotifier();
49065 
49066  static const HPS::Type staticType = HPS::Type::PointCloudImportNotifier;
49067  HPS::Type ObjectType() const {return staticType;};
49068 
49072  ImportNotifier & operator=(ImportNotifier const & in_that);
49073 
49076  void Assign(ImportNotifier const & in_that);
49077 
49081  ImportResultsKit GetResults() const;
49082  };
49083 
49084 
49086  class HPS_API File
49087  {
49088  public:
49094  static ImportNotifier Import(char const * in_file_name, ImportOptionsKit const & in_options);
49095 
49096  private:
49098  File();
49099  };
49100 private:
49102  PointCloud();
49103 };
49104 
49108 
49110 class HPS_API Stream
49111 {
49112 public:
49113  class ImportNotifier;
49114  class ImportOptionsKit;
49115 
49117  class HPS_API Toolkit : public Object
49118  {
49119  public:
49121  Toolkit();
49122 
49125  Toolkit(Toolkit const & in_toolkit);
49126 
49130  Toolkit(Toolkit && in_toolkit);
49131 
49135  Toolkit & operator=(Toolkit const & in_toolkit);
49136 
49140  Toolkit & operator=(Toolkit && in_toolkit);
49141 
49142  static const HPS::Type staticType = HPS::Type::StreamToolkit;
49143  HPS::Type ObjectType() const { return staticType; }
49144 
49146  virtual void Restart();
49147 
49148  ImportNotifier ParseBuffers(ByteArrayArray const & in_hsf_buffers, ImportOptionsKit const & in_options);
49149  };
49150 
49153  static Toolkit CreateToolkit();
49154 
49155 
49156 
49158 
49160  class HPS_API ExportEvent
49161  {
49162  protected:
49163  ExportEvent() {}
49164  public:
49165  virtual ~ExportEvent();
49167  intptr_t GetClassID() const;
49171  };
49172 
49174  class HPS_API ExportEventHandler
49175  {
49176  public:
49177  ExportEventHandler() {}
49178  virtual ~ExportEventHandler();
49182  virtual void Handle(ExportEvent * in_event);
49183  };
49184 
49186 
49188  class HPS_API GeometryExportEvent : public ExportEvent
49189  {
49191  GeometryExportEvent & operator=(GeometryExportEvent const &);
49192  public:
49193  GeometryExportEvent();
49194  virtual ~GeometryExportEvent();
49195  GeometryExportEvent(HPS::Key & in_key);
49196 
49199  };
49200 
49202  class HPS_API SegmentExportEvent : public ExportEvent
49203  {
49205  SegmentExportEvent & operator=(SegmentExportEvent const &);
49206  public:
49207  SegmentExportEvent();
49208  virtual ~SegmentExportEvent();
49209  SegmentExportEvent(HPS::SegmentKey & in_segment_key);
49210 
49213  };
49214 
49216 
49218  class HPS_API ImportEvent
49219  {
49220  protected:
49221  ImportEvent() {}
49222  public:
49223  virtual ~ImportEvent();
49225  intptr_t GetClassID() const;
49226  };
49227 
49232  class HPS_API ImportEventHandler
49233  {
49234  public:
49235  ImportEventHandler() {}
49236  virtual ~ImportEventHandler();
49237 
49243  virtual bool Handle(ImportEvent * in_event);
49244  };
49245 
49247 
49248  class HPS_API AttributeLockImportEvent : public ImportEvent
49249  {
49251  AttributeLockImportEvent & operator=(AttributeLockImportEvent const &);
49252  public:
49253  AttributeLockImportEvent();
49254  virtual ~AttributeLockImportEvent();
49255  AttributeLockImportEvent(HPS::SegmentKey & in_segment_key, HPS::AttributeLockKit & in_attribute_lock_kit);
49256 
49257  HPS::SegmentKey & segment_key;
49258  HPS::AttributeLockKit & attribute_lock_kit;
49259  };
49260 
49261  class HPS_API BoundingImportEvent : public ImportEvent
49262  {
49264  BoundingImportEvent & operator=(BoundingImportEvent const &);
49265  public:
49266  BoundingImportEvent();
49267  virtual ~BoundingImportEvent();
49268  BoundingImportEvent(HPS::SegmentKey & in_segment_key, HPS::BoundingKit & in_bounding_kit);
49269 
49270  HPS::SegmentKey & segment_key;
49271  HPS::BoundingKit & bounding_kit;
49272  };
49273 
49274  class HPS_API CameraImportEvent : public ImportEvent
49275  {
49277  CameraImportEvent & operator=(CameraImportEvent const &);
49278  public:
49279  CameraImportEvent();
49280  virtual ~CameraImportEvent();
49281  CameraImportEvent(HPS::SegmentKey & in_segment_key, HPS::CameraKit & in_camera_kit);
49282 
49283  HPS::SegmentKey & segment_key;
49284  HPS::CameraKit & camera_kit;
49285  };
49286 
49287  class HPS_API CircleImportEvent : public ImportEvent
49288  {
49290  CircleImportEvent & operator=(CircleImportEvent const &);
49291  public:
49292  CircleImportEvent();
49293  virtual ~CircleImportEvent();
49294  CircleImportEvent(HPS::SegmentKey & in_segment_key, HPS::CircleKit & in_circle_kit);
49295 
49296  HPS::SegmentKey & segment_key;
49297  HPS::CircleKit & circle_kit;
49298  };
49299 
49300  class HPS_API CircularArcImportEvent : public ImportEvent
49301  {
49303  CircularArcImportEvent & operator=(CircularArcImportEvent const &);
49304  public:
49305  CircularArcImportEvent();
49306  virtual ~CircularArcImportEvent();
49307  CircularArcImportEvent(HPS::SegmentKey & in_segment_key, HPS::CircularArcKit & in_circular_arc_kit);
49308 
49309  HPS::SegmentKey & segment_key;
49310  HPS::CircularArcKit & circular_arc_kit;
49311  };
49312 
49313  class HPS_API CircularWedgeImportEvent : public ImportEvent
49314  {
49316  CircularWedgeImportEvent & operator=(CircularWedgeImportEvent const &);
49317  public:
49318  CircularWedgeImportEvent();
49319  virtual ~CircularWedgeImportEvent();
49320  CircularWedgeImportEvent(HPS::SegmentKey & in_segment_key, HPS::CircularWedgeKit & in_circular_wedge_kit);
49321 
49322  HPS::SegmentKey & segment_key;
49323  HPS::CircularWedgeKit & circular_wedge_kit;
49324  };
49325 
49327  {
49329  ColorInterpolationImportEvent & operator=(ColorInterpolationImportEvent const &);
49330  public:
49331  ColorInterpolationImportEvent();
49332  virtual ~ColorInterpolationImportEvent();
49333  ColorInterpolationImportEvent(HPS::SegmentKey & in_segment_key, HPS::ColorInterpolationKit & in_color_interpolation_kit);
49334 
49335  HPS::SegmentKey & segment_key;
49336  HPS::ColorInterpolationKit & color_interpolation_kit;
49337  };
49338 
49339  class HPS_API CommentImportEvent : public ImportEvent
49340  {
49342  CommentImportEvent & operator=(CommentImportEvent const &);
49343  public:
49344  CommentImportEvent();
49345  virtual ~CommentImportEvent();
49346  CommentImportEvent(HPS::SegmentKey & in_segment_key, const char* in_comment);
49347 
49348  HPS::SegmentKey & segment_key;
49349  HPS::UTF8 const comment;
49350  };
49351 
49352  class HPS_API ConditionImportEvent : public ImportEvent
49353  {
49355  ConditionImportEvent & operator=(ConditionImportEvent const &);
49356  public:
49357  ConditionImportEvent();
49358  virtual ~ConditionImportEvent();
49359  ConditionImportEvent(HPS::SegmentKey & in_segment_key);
49360 
49361  HPS::SegmentKey & segment_key;
49362  HPS::UTF8Array conditions;
49363  };
49364 
49365  class HPS_API ContourLineImportEvent : public ImportEvent
49366  {
49368  ContourLineImportEvent & operator=(ContourLineImportEvent const &);
49369  public:
49370  ContourLineImportEvent();
49371  virtual ~ContourLineImportEvent();
49372  ContourLineImportEvent(HPS::SegmentKey & in_segment_key, HPS::ContourLineKit & in_contour_line_kit);
49373 
49374  HPS::SegmentKey & segment_key;
49375  HPS::ContourLineKit & contour_line_kit;
49376  };
49377 
49379  {
49381  CuttingSectionImportEvent & operator=(CuttingSectionImportEvent const &);
49382  public:
49383  CuttingSectionImportEvent();
49384  virtual ~CuttingSectionImportEvent();
49385  CuttingSectionImportEvent(HPS::SegmentKey & in_segment_key, HPS::CuttingSectionKit & in_cutting_section_kit);
49386 
49387  HPS::SegmentKey & segment_key;
49388  HPS::CuttingSectionKit & cutting_section_kit;
49389  };
49390 
49392  {
49394  CuttingSectionAttributeImportEvent & operator=(CuttingSectionAttributeImportEvent const &);
49395  public:
49396  CuttingSectionAttributeImportEvent();
49397  virtual ~CuttingSectionAttributeImportEvent();
49398  CuttingSectionAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::CuttingSectionAttributeKit & in_cutting_section_attribute_kit);
49399 
49400  HPS::SegmentKey & segment_key;
49401  HPS::CuttingSectionAttributeKit & cutting_section_attribute_kit;
49402  };
49403 
49405  {
49407  CubeMapDefinitionImportEvent & operator=(CubeMapDefinitionImportEvent const &);
49408  public:
49409  CubeMapDefinitionImportEvent();
49410  virtual ~CubeMapDefinitionImportEvent();
49411  CubeMapDefinitionImportEvent(HPS::PortfolioKey & in_portfolio_key, const char * in_name,
49412  HPS::ImageDefinition & in_negative_z, HPS::ImageDefinition & in_positive_z,
49413  HPS::ImageDefinition & in_negative_x, HPS::ImageDefinition & in_positive_x,
49414  HPS::ImageDefinition & in_negative_y, HPS::ImageDefinition & in_positive_y,
49415  HPS::TextureOptionsKit & in_texture_kit);
49416 
49417  HPS::PortfolioKey & portfolio_key;
49418  UTF8 name;
49419  HPS::ImageDefinition & negative_z;
49420  HPS::ImageDefinition & positive_z;
49421  HPS::ImageDefinition & negative_x;
49422  HPS::ImageDefinition & positive_x;
49423  HPS::ImageDefinition & negative_y;
49424  HPS::ImageDefinition & positive_y;
49425  HPS::TextureOptionsKit & texture_kit;
49426  };
49427 
49428  class HPS_API CullingImportEvent : public ImportEvent
49429  {
49431  CullingImportEvent & operator=(CullingImportEvent const &);
49432  public:
49433  CullingImportEvent();
49434  virtual ~CullingImportEvent();
49435  CullingImportEvent(HPS::SegmentKey & in_segment_key, HPS::CullingKit & in_culling_kit);
49436 
49437  HPS::SegmentKey & segment_key;
49438  HPS::CullingKit & culling_kit;
49439  };
49440 
49442  {
49444  CurveAttributeImportEvent & operator=(CurveAttributeImportEvent const &);
49445  public:
49446  CurveAttributeImportEvent();
49447  virtual ~CurveAttributeImportEvent();
49448  CurveAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::CurveAttributeKit & in_curve_attribute_kit);
49449 
49450  HPS::SegmentKey & segment_key;
49451  HPS::CurveAttributeKit & curve_attribute_kit;
49452  };
49453 
49455  {
49457  CylinderAttributeImportEvent & operator=(CylinderAttributeImportEvent const &);
49458  public:
49459  CylinderAttributeImportEvent();
49460  virtual ~CylinderAttributeImportEvent();
49461  CylinderAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::CylinderAttributeKit & in_cylinder_attribute_kit);
49462 
49463  HPS::SegmentKey & segment_key;
49464  HPS::CylinderAttributeKit & cylinder_attribute_kit;
49465  };
49466 
49467  class HPS_API CylinderImportEvent : public ImportEvent
49468  {
49470  CylinderImportEvent & operator=(CylinderImportEvent const &);
49471  public:
49472  CylinderImportEvent();
49473  virtual ~CylinderImportEvent();
49474  CylinderImportEvent(HPS::SegmentKey & in_segment_key, HPS::CylinderKit & in_cylinder_kit);
49475 
49476  HPS::SegmentKey & segment_key;
49477  HPS::CylinderKit & cylinder_kit;
49478  };
49479 
49481  {
49483  DistantLightPropertyImportEvent & operator=(DistantLightPropertyImportEvent const &);
49484  public:
49485  DistantLightPropertyImportEvent();
49486  virtual ~DistantLightPropertyImportEvent();
49487  DistantLightPropertyImportEvent(HPS::DistantLightKey & in_distant_light_key, HPS::DistantLightKit & in_distant_light_kit);
49488 
49489  HPS::DistantLightKey & distant_light_key;
49490  HPS::DistantLightKit & distant_light_kit;
49491  };
49492 
49493  class HPS_API DistantLightImportEvent : public ImportEvent
49494  {
49496  DistantLightImportEvent & operator=(DistantLightImportEvent const &);
49497  public:
49498  DistantLightImportEvent();
49499  virtual ~DistantLightImportEvent();
49500  DistantLightImportEvent(HPS::SegmentKey & in_segment_key, HPS::DistantLightKit & in_distantlight_kit);
49501 
49502  HPS::SegmentKey & segment_key;
49503  HPS::DistantLightKit & distant_light_kit;
49504  };
49505 
49507  {
49509  DrawingAttributeImportEvent & operator=(DrawingAttributeImportEvent const &);
49510  public:
49511  DrawingAttributeImportEvent();
49512  virtual ~DrawingAttributeImportEvent();
49513  DrawingAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::DrawingAttributeKit & in_drawing_attribute_kit);
49514 
49515  HPS::SegmentKey & segment_key;
49516  HPS::DrawingAttributeKit & drawing_attribute_kit;
49517  };
49518 
49519  class HPS_API EdgeAttributeImportEvent : public ImportEvent
49520  {
49522  EdgeAttributeImportEvent & operator=(EdgeAttributeImportEvent const &);
49523  public:
49524  EdgeAttributeImportEvent();
49525  virtual ~EdgeAttributeImportEvent();
49526  EdgeAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::EdgeAttributeKit & in_edge_attribute_kit);
49527 
49528  HPS::SegmentKey & segment_key;
49529  HPS::EdgeAttributeKit & edge_attribute_kit;
49530  };
49531 
49532  class HPS_API EllipseImportEvent : public ImportEvent
49533  {
49535  EllipseImportEvent & operator=(EllipseImportEvent const &);
49536  public:
49537  EllipseImportEvent();
49538  virtual ~EllipseImportEvent();
49539  EllipseImportEvent(HPS::SegmentKey & in_segment_key, HPS::EllipseKit & in_ellipse_kit);
49540 
49541  HPS::SegmentKey & segment_key;
49542  HPS::EllipseKit & ellipse_kit;
49543  };
49544 
49545  class HPS_API EllipticalArcImportEvent : public ImportEvent
49546  {
49548  EllipticalArcImportEvent & operator=(EllipticalArcImportEvent const &);
49549  public:
49550  EllipticalArcImportEvent();
49551  virtual ~EllipticalArcImportEvent();
49552  EllipticalArcImportEvent(HPS::SegmentKey & in_segment_key, HPS::EllipticalArcKit & in_elliptical_arc_kit);
49553 
49554  HPS::SegmentKey & segment_key;
49555  HPS::EllipticalArcKit & elliptical_arc_kit;
49556  };
49557 
49559  {
49561  GlyphDefinitionImportEvent & operator=(GlyphDefinitionImportEvent const &);
49562  public:
49563  GlyphDefinitionImportEvent();
49564  virtual ~GlyphDefinitionImportEvent();
49565  GlyphDefinitionImportEvent(HPS::PortfolioKey & in_portfolio_key, const char * in_name, HPS::GlyphKit & in_glyph_kit);
49566 
49567  HPS::PortfolioKey & portfolio_key;
49568  UTF8 name;
49569  HPS::GlyphKit & glyph_kit;
49570  };
49571 
49573  {
49575  ShapeDefinitionImportEvent & operator=(ShapeDefinitionImportEvent const &);
49576  public:
49577  ShapeDefinitionImportEvent();
49578  virtual ~ShapeDefinitionImportEvent();
49579  ShapeDefinitionImportEvent(HPS::PortfolioKey & in_portfolio_key, const char * in_name, HPS::ShapeKit & in_shape_kit);
49580 
49581  HPS::PortfolioKey & portfolio_key;
49582  UTF8 name;
49583  HPS::ShapeKit & shape_kit;
49584  };
49585 
49586  class HPS_API GridImportEvent : public ImportEvent
49587  {
49589  GridImportEvent & operator=(GridImportEvent const &);
49590  public:
49591  GridImportEvent();
49592  virtual ~GridImportEvent();
49593  GridImportEvent(HPS::SegmentKey & in_segment_key, HPS::GridKit & in_grid_kit);
49594 
49595  HPS::SegmentKey & segment_key;
49596  HPS::GridKit & grid_kit;
49597  };
49598 
49600  {
49602  HiddenLineAttributeImportEvent & operator=(HiddenLineAttributeImportEvent const &);
49603  public:
49604  HiddenLineAttributeImportEvent();
49605  virtual ~HiddenLineAttributeImportEvent();
49606  HiddenLineAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::HiddenLineAttributeKit & in_hidden_attribute_kit);
49607 
49608  HPS::SegmentKey & segment_key;
49609  HPS::HiddenLineAttributeKit & hidden_line_attribute_kit;
49610  };
49611 
49613  {
49615  ImageDefinitionImportEvent & operator=(ImageDefinitionImportEvent const &);
49616  public:
49617  ImageDefinitionImportEvent();
49618  virtual ~ImageDefinitionImportEvent();
49619  ImageDefinitionImportEvent(HPS::PortfolioKey & in_portfolio_key, const char * in_name, HPS::ImageKit & in_image_kit);
49620 
49621  HPS::PortfolioKey & portfolio_key;
49622  UTF8 name;
49623  HPS::ImageKit & image_kit;
49624  };
49625 
49627  {
49629  IncludeSegmentImportEvent & operator=(IncludeSegmentImportEvent const &);
49630  public:
49631  IncludeSegmentImportEvent();
49632  virtual ~IncludeSegmentImportEvent();
49633  IncludeSegmentImportEvent(HPS::SegmentKey & in_segment_key, HPS::SegmentKey & in_reference_segment_key, HPS::ConditionalExpression & in_conditional, HPS::AttributeLockTypeArray && in_filter_types);
49634 
49635  HPS::SegmentKey & segment_key;
49636  HPS::SegmentKey & reference_segment_key;
49637  HPS::ConditionalExpression & condition;
49638  HPS::AttributeLockTypeArray filter_types;
49639  };
49640 
49641  class HPS_API InfiniteLineImportEvent : public ImportEvent
49642  {
49644  InfiniteLineImportEvent & operator=(InfiniteLineImportEvent const &);
49645  public:
49646  InfiniteLineImportEvent();
49647  virtual ~InfiniteLineImportEvent();
49648  InfiniteLineImportEvent(HPS::SegmentKey & in_segment_key, HPS::InfiniteLineKit & in_infinite_line_kit);
49649 
49650  HPS::SegmentKey & segment_key;
49651  HPS::InfiniteLineKit & infinite_line_kit;
49652  };
49653 
49655  {
49657  LightingAttributeImportEvent & operator=(LightingAttributeImportEvent const &);
49658  public:
49659  LightingAttributeImportEvent();
49660  virtual ~LightingAttributeImportEvent();
49661  LightingAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::LightingAttributeKit & in_lighting_attribute_kit);
49662 
49663  HPS::SegmentKey & segment_key;
49664  HPS::LightingAttributeKit & lighting_attribute_kit;
49665  };
49666 
49667  class HPS_API LineAttributeImportEvent : public ImportEvent
49668  {
49670  LineAttributeImportEvent & operator=(LineAttributeImportEvent const &);
49671  public:
49672  LineAttributeImportEvent();
49673  virtual ~LineAttributeImportEvent();
49674  LineAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::LineAttributeKit & in_line_attribute_kit);
49675 
49676  HPS::SegmentKey & segment_key;
49677  HPS::LineAttributeKit & line_attribute_kit;
49678  };
49679 
49680  class HPS_API LineImportEvent : public ImportEvent
49681  {
49683  LineImportEvent & operator=(LineImportEvent const &);
49684  public:
49685  LineImportEvent();
49686  virtual ~LineImportEvent();
49687  LineImportEvent(HPS::SegmentKey & in_segment_key, HPS::LineKit & in_line_kit);
49688 
49689  HPS::SegmentKey & segment_key;
49690  HPS::LineKit & line_kit;
49691  };
49692 
49694  {
49696  LinePatternDefinitionImportEvent & operator=(LinePatternDefinitionImportEvent const &);
49697  public:
49698  LinePatternDefinitionImportEvent();
49699  virtual ~LinePatternDefinitionImportEvent();
49700  LinePatternDefinitionImportEvent(HPS::PortfolioKey & in_portfolio_key, const char * in_name, HPS::LinePatternKit & in_line_pattern_kit);
49701 
49702  HPS::PortfolioKey & portfolio_key;
49703  UTF8 name;
49704  HPS::LinePatternKit & line_pattern_kit;
49705  };
49706 
49707  class HPS_API MarkerImportEvent : public ImportEvent
49708  {
49710  MarkerImportEvent & operator=(MarkerImportEvent const &);
49711  public:
49712  MarkerImportEvent();
49713  virtual ~MarkerImportEvent();
49714  MarkerImportEvent(HPS::SegmentKey & in_segment_key, HPS::MarkerKit & in_marker_kit);
49715 
49716  HPS::SegmentKey & segment_key;
49717  HPS::MarkerKit & marker_kit;
49718  };
49719 
49721  {
49723  MarkerAttributeImportEvent & operator=(MarkerAttributeImportEvent const &);
49724  public:
49725  MarkerAttributeImportEvent();
49726  virtual ~MarkerAttributeImportEvent();
49727  MarkerAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::MarkerAttributeKit & in_marker_attribute_kit);
49728 
49729  HPS::SegmentKey & segment_key;
49730  HPS::MarkerAttributeKit & marker_attribute_kit;
49731  };
49732 
49733  class HPS_API MaterialImportEvent : public ImportEvent
49734  {
49736  MaterialImportEvent & operator=(MaterialImportEvent const &);
49737  public:
49738  MaterialImportEvent();
49739  virtual ~MaterialImportEvent();
49740  MaterialImportEvent(HPS::Key & in_key, HPS::MaterialMappingKit & in_material_mapping_kit);
49741 
49742  HPS::Key & key;
49743  HPS::MaterialMappingKit & material_mapping_kit;
49744  };
49745 
49747  {
49749  MaterialPaletteDefinitionImportEvent & operator=(MaterialPaletteDefinitionImportEvent const &);
49750  public:
49751  MaterialPaletteDefinitionImportEvent();
49752  virtual ~MaterialPaletteDefinitionImportEvent();
49753  MaterialPaletteDefinitionImportEvent(HPS::PortfolioKey & in_portfolio_key, const char * in_name, HPS::MaterialKitArray & in_material_mapping_kit_array);
49754 
49755  HPS::PortfolioKey & portfolio_key;
49756  HPS::UTF8 name;
49757  HPS::MaterialKitArray & material_mapping_kit_array;
49758  };
49759 
49761  {
49763  MaterialPaletteImportEvent & operator=(MaterialPaletteImportEvent const &);
49764  public:
49765  MaterialPaletteImportEvent();
49766  virtual ~MaterialPaletteImportEvent();
49767  MaterialPaletteImportEvent(HPS::SegmentKey & in_segment_key, const char * in_name);
49768 
49769  HPS::SegmentKey & segment_key;
49770  HPS::UTF8 name;
49771  };
49772 
49773  class HPS_API MatrixImportEvent : public ImportEvent
49774  {
49776  MatrixImportEvent & operator=(MatrixImportEvent const &);
49777  public:
49778  MatrixImportEvent();
49779  virtual ~MatrixImportEvent();
49780  MatrixImportEvent(HPS::Key & in_key, HPS::MatrixKit & in_matrix_kit);
49781 
49782  HPS::Key & key;
49783  HPS::MatrixKit & matrix_kit;
49784  };
49785 
49786  class HPS_API MeshImportEvent : public ImportEvent
49787  {
49789  MeshImportEvent & operator=(MeshImportEvent const &);
49790  public:
49791  MeshImportEvent();
49792  virtual ~MeshImportEvent();
49793  MeshImportEvent(HPS::SegmentKey & in_segment_key, HPS::MeshKit & in_mesh_kit);
49794 
49795  HPS::SegmentKey & segment_key;
49796  HPS::MeshKit & mesh_kit;
49797  };
49798 
49799  class HPS_API MeshInstanceImportEvent : public ImportEvent
49800  {
49802  MeshInstanceImportEvent & operator=(MeshInstanceImportEvent const &);
49803  public:
49804  MeshInstanceImportEvent();
49805  virtual ~MeshInstanceImportEvent();
49806  MeshInstanceImportEvent(HPS::SegmentKey & in_segment_key, HPS::MeshKit & in_mesh_kit, HPS::MatrixKit & in_modelling_matrix);
49807 
49808  HPS::SegmentKey & segment_key;
49809  HPS::MeshKit & mesh_kit;
49810  HPS::MatrixKit & modelling_matrix;
49811  };
49812 
49814  {
49816  NamedStyleDefinitionImportEvent & operator=(NamedStyleDefinitionImportEvent const &);
49817  public:
49818  NamedStyleDefinitionImportEvent();
49819  virtual ~NamedStyleDefinitionImportEvent();
49820  NamedStyleDefinitionImportEvent(HPS::PortfolioKey & in_portfolio_key, const char * in_name, HPS::SegmentKey & in_style_key);
49821 
49822  HPS::PortfolioKey & portfolio_key;
49823  HPS::UTF8 name;
49824  HPS::SegmentKey & style_key;
49825  };
49826 
49827  class HPS_API NamedStyleImportEvent : public ImportEvent
49828  {
49830  NamedStyleImportEvent & operator=(NamedStyleImportEvent const &);
49831  public:
49832  NamedStyleImportEvent();
49833  virtual ~NamedStyleImportEvent();
49834  NamedStyleImportEvent(HPS::SegmentKey & in_segment_key, const char * in_name, HPS::ConditionalExpression & in_conditional, HPS::AttributeLockTypeArray && in_filter_types);
49835 
49836  HPS::SegmentKey & segment_key;
49837  HPS::UTF8 name;
49838  HPS::ConditionalExpression & condition;
49839  HPS::AttributeLockTypeArray filter_types;
49840  };
49841 
49842  class HPS_API NURBSCurveImportEvent : public ImportEvent
49843  {
49845  NURBSCurveImportEvent & operator=(NURBSCurveImportEvent const &);
49846  public:
49847  NURBSCurveImportEvent();
49848  virtual ~NURBSCurveImportEvent();
49849  NURBSCurveImportEvent(HPS::SegmentKey & in_segment_key, HPS::NURBSCurveKit & in_nurbs_curve_kit);
49850 
49851  HPS::SegmentKey & segment_key;
49852  HPS::NURBSCurveKit & nurbs_curve_kit;
49853  };
49854 
49855  class HPS_API NURBSSurfaceImportEvent : public ImportEvent
49856  {
49858  NURBSSurfaceImportEvent & operator=(NURBSSurfaceImportEvent const &);
49859  public:
49860  NURBSSurfaceImportEvent();
49861  virtual ~NURBSSurfaceImportEvent();
49862  NURBSSurfaceImportEvent(HPS::SegmentKey & in_segment_key, HPS::NURBSSurfaceKit & in_nurbs_surface_kit);
49863 
49864  HPS::SegmentKey & segment_key;
49865  HPS::NURBSSurfaceKit & nurbs_surface_kit;
49866  };
49867 
49869  {
49871  NURBSSurfaceAttributeImportEvent & operator=(NURBSSurfaceAttributeImportEvent const &);
49872  public:
49873  NURBSSurfaceAttributeImportEvent();
49874  virtual ~NURBSSurfaceAttributeImportEvent();
49875  NURBSSurfaceAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::NURBSSurfaceAttributeKit & in_nurbs_surface_attribute_kit);
49876 
49877  HPS::SegmentKey & segment_key;
49878  HPS::NURBSSurfaceAttributeKit & nurbs_surface_attribute_kit;
49879  };
49880 
49881  class HPS_API PerformanceImportEvent : public ImportEvent
49882  {
49884  PerformanceImportEvent & operator=(PerformanceImportEvent const &);
49885  public:
49886  PerformanceImportEvent();
49887  virtual ~PerformanceImportEvent();
49888  PerformanceImportEvent(HPS::SegmentKey & in_segment_key, HPS::PerformanceKit & in_performance_kit);
49889 
49890  HPS::SegmentKey & segment_key;
49891  HPS::PerformanceKit & performance_kit;
49892  };
49893 
49894  class HPS_API PolygonImportEvent : public ImportEvent
49895  {
49897  PolygonImportEvent & operator=(PolygonImportEvent const &);
49898  public:
49899  PolygonImportEvent();
49900  virtual ~PolygonImportEvent();
49901  PolygonImportEvent(HPS::SegmentKey & in_segment_key, HPS::PolygonKit & in_polygon_kit);
49902 
49903  HPS::SegmentKey & segment_key;
49904  HPS::PolygonKit & polygon_kit;
49905  };
49906 
49907  class HPS_API PriorityImportEvent : public ImportEvent
49908  {
49910  PriorityImportEvent & operator=(PriorityImportEvent const &);
49911  public:
49912  PriorityImportEvent();
49913  virtual ~PriorityImportEvent();
49914  PriorityImportEvent(HPS::Key & in_key, int in_priority);
49915 
49916  HPS::Key & key;
49917  int priority;
49918  };
49919 
49921  {
49923  ReferenceGeometryImportEvent & operator=(ReferenceGeometryImportEvent const &);
49924  public:
49925  ReferenceGeometryImportEvent();
49926  virtual ~ReferenceGeometryImportEvent();
49927  ReferenceGeometryImportEvent(HPS::SegmentKey & in_segment_key, HPS::Key & in_reference_geometry_key, HPS::ConditionalExpression & in_conditional);
49928 
49929  HPS::SegmentKey & segment_key;
49930  HPS::Key & reference_geometry_key;
49931  HPS::ConditionalExpression & condition;
49932  };
49933 
49934  class HPS_API SegmentImportEvent : public ImportEvent
49935  {
49937  SegmentImportEvent & operator=(SegmentImportEvent const &);
49938  public:
49939  SegmentImportEvent();
49940  virtual ~SegmentImportEvent();
49941  SegmentImportEvent(HPS::SegmentKey & in_segment_key, const char * in_name);
49942 
49943  HPS::SegmentKey & segment_key;
49944  HPS::UTF8 name;
49945  };
49946 
49947  class HPS_API SelectabilityImportEvent : public ImportEvent
49948  {
49950  SelectabilityImportEvent & operator=(SelectabilityImportEvent const &);
49951  public:
49952  SelectabilityImportEvent();
49953  virtual ~SelectabilityImportEvent();
49954  SelectabilityImportEvent(HPS::SegmentKey & in_segment_key, HPS::SelectabilityKit & in_selectability_kit);
49955 
49956  HPS::SegmentKey & segment_key;
49957  HPS::SelectabilityKit & selectability_kit;
49958  };
49959 
49961  {
49963  ShaderDefinitionImportEvent & operator=(ShaderDefinitionImportEvent const &);
49964  public:
49965  ShaderDefinitionImportEvent();
49966  virtual ~ShaderDefinitionImportEvent();
49967  ShaderDefinitionImportEvent(HPS::PortfolioKey & in_portfolio_key, const char * in_name, HPS::ShaderKit & in_shader_kit);
49968 
49969  HPS::PortfolioKey & portfolio_key;
49970  UTF8 name;
49971  HPS::ShaderKit & shader_kit;
49972  };
49973 
49974  class HPS_API ShellImportEvent : public ImportEvent
49975  {
49977  ShellImportEvent & operator=(ShellImportEvent const &);
49978  public:
49979  ShellImportEvent();
49980  virtual ~ShellImportEvent();
49981  ShellImportEvent(HPS::SegmentKey & in_segment_key, HPS::ShellKit & in_shell_kit);
49982 
49983  HPS::SegmentKey & segment_key;
49984  HPS::ShellKit & shell_kit;
49985  };
49986 
49987  class HPS_API ShellInstanceImportEvent : public ImportEvent
49988  {
49990  ShellInstanceImportEvent & operator=(ShellInstanceImportEvent const &);
49991  public:
49992  ShellInstanceImportEvent();
49993  virtual ~ShellInstanceImportEvent();
49994  ShellInstanceImportEvent(HPS::SegmentKey & in_segment_key, HPS::ShellKit & in_shell_kit, HPS::MatrixKit & in_modelling_matrix);
49995 
49996  HPS::SegmentKey & segment_key;
49997  HPS::ShellKit & shell_kit;
49998  HPS::MatrixKit & modelling_matrix;
49999  };
50000 
50001  class HPS_API SphereImportEvent : public ImportEvent
50002  {
50004  SphereImportEvent & operator=(SphereImportEvent const &);
50005  public:
50006  SphereImportEvent();
50007  virtual ~SphereImportEvent();
50008  SphereImportEvent(HPS::SegmentKey & in_segment_key, HPS::SphereKit & in_sphere_kit);
50009 
50010  HPS::SegmentKey & segment_key;
50011  HPS::SphereKit & sphere_kit;
50012  };
50013 
50015  {
50017  SphereAttributeImportEvent & operator=(SphereAttributeImportEvent const &);
50018  public:
50019  SphereAttributeImportEvent();
50020  virtual ~SphereAttributeImportEvent();
50021  SphereAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::SphereAttributeKit & in_sphere_attribute_kit);
50022 
50023  HPS::SegmentKey & segment_key;
50024  HPS::SphereAttributeKit & sphere_attribute_kit;
50025  };
50026 
50027  class HPS_API SpotlightImportEvent : public ImportEvent
50028  {
50030  SpotlightImportEvent & operator=(SpotlightImportEvent const &);
50031  public:
50032  SpotlightImportEvent();
50033  virtual ~SpotlightImportEvent();
50034  SpotlightImportEvent(HPS::SegmentKey & in_segment_key, HPS::SpotlightKit & in_spotlight_kit);
50035 
50036  HPS::SegmentKey & segment_key;
50037  HPS::SpotlightKit & spotlight_kit;
50038  };
50039 
50040  class HPS_API StyleSegmentImportEvent : public ImportEvent
50041  {
50043  StyleSegmentImportEvent & operator=(StyleSegmentImportEvent const &);
50044  public:
50045  StyleSegmentImportEvent();
50046  virtual ~StyleSegmentImportEvent();
50047  StyleSegmentImportEvent(HPS::SegmentKey & in_segment_key, HPS::SegmentKey & in_style_segment_key, HPS::ConditionalExpression & in_conditional, HPS::AttributeLockTypeArray && in_filter_types);
50048 
50049  HPS::SegmentKey & segment_key;
50050  HPS::SegmentKey & style_segment_key;
50051  HPS::ConditionalExpression & condition;
50052  HPS::AttributeLockTypeArray filter_types;
50053  };
50054 
50055  class HPS_API TextImportEvent : public ImportEvent
50056  {
50058  TextImportEvent & operator=(TextImportEvent const &);
50059  public:
50060  TextImportEvent();
50061  virtual ~TextImportEvent();
50062  TextImportEvent(HPS::SegmentKey & in_segment_key, HPS::TextKit & in_text_kit);
50063 
50064  HPS::SegmentKey & segment_key;
50065  HPS::TextKit & text_kit;
50066  };
50067 
50068  class HPS_API TextAttributeImportEvent : public ImportEvent
50069  {
50071  TextAttributeImportEvent & operator=(TextAttributeImportEvent const &);
50072  public:
50073  TextAttributeImportEvent();
50074  virtual ~TextAttributeImportEvent();
50075  TextAttributeImportEvent(HPS::TextKey & in_text_key, HPS::TextAttributeKit & in_text_attribute_kit);
50076  TextAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::TextAttributeKit & in_text_attribute_kit);
50077 
50078  HPS::Key & key;
50079  HPS::TextAttributeKit & text_attribute_kit;
50080  };
50081 
50083  {
50085  TextureDefinitionImportEvent & operator=(TextureDefinitionImportEvent const &);
50086  public:
50087  TextureDefinitionImportEvent();
50088  virtual ~TextureDefinitionImportEvent();
50089  TextureDefinitionImportEvent(HPS::PortfolioKey & in_portfolio_key, const char * in_name,
50090  HPS::ImageDefinition & in_source_definition, HPS::TextureOptionsKit & in_texture_kit);
50091 
50092  HPS::PortfolioKey & portfolio_key;
50093  UTF8 name;
50094  HPS::ImageDefinition & source_definition;
50095  HPS::TextureOptionsKit & texture_kit;
50096  };
50097 
50098  class HPS_API TransformMaskImportEvent : public ImportEvent
50099  {
50101  TransformMaskImportEvent & operator=(TransformMaskImportEvent const &);
50102  public:
50103  TransformMaskImportEvent();
50104  virtual ~TransformMaskImportEvent();
50105  TransformMaskImportEvent(HPS::SegmentKey & in_segment_key, HPS::TransformMaskKit & in_transform_mask_kit);
50106 
50107  HPS::SegmentKey & segment_key;
50108  HPS::TransformMaskKit & transform_mask_kit;
50109  };
50110 
50111  class HPS_API TransparencyImportEvent : public ImportEvent
50112  {
50114  TransparencyImportEvent & operator=(TransparencyImportEvent const &);
50115  public:
50116  TransparencyImportEvent();
50117  virtual ~TransparencyImportEvent();
50118  TransparencyImportEvent(HPS::SegmentKey & in_segment_key, HPS::TransparencyKit & in_transparency_kit);
50119 
50120  HPS::SegmentKey & segment_key;
50121  HPS::TransparencyKit & transparency_kit;
50122  };
50123 
50124  class HPS_API SubwindowImportEvent : public ImportEvent
50125  {
50127  SubwindowImportEvent & operator=(SubwindowImportEvent const &);
50128  public:
50129  SubwindowImportEvent();
50130  virtual ~SubwindowImportEvent();
50131  SubwindowImportEvent(HPS::SegmentKey & in_segment_key, HPS::SubwindowKit & in_subwindow_kit);
50132 
50133  HPS::SegmentKey & segment_key;
50134  HPS::SubwindowKit & subwindow_kit;
50135  };
50136 
50138  class HPS_API NonDBUserDataImportEvent : public ImportEvent
50139  {
50141  NonDBUserDataImportEvent & operator=(NonDBUserDataImportEvent const &);
50142  public:
50143  NonDBUserDataImportEvent() {}
50144  virtual ~NonDBUserDataImportEvent();
50145  NonDBUserDataImportEvent(size_t in_count, HPS::byte const in_data[]);
50146 
50149  };
50150 
50152  class HPS_API UserDataImportEvent : public ImportEvent
50153  {
50155  UserDataImportEvent & operator=(UserDataImportEvent const &);
50156  public:
50157  virtual ~UserDataImportEvent();
50158  UserDataImportEvent();
50159  UserDataImportEvent(HPS::Key & in_key, intptr_t in_index, size_t in_count, HPS::byte const in_data[]);
50160 
50161  HPS::Key key;
50162  intptr_t index;
50163 
50166  };
50167 
50168  class HPS_API VisibilityImportEvent : public ImportEvent
50169  {
50171  VisibilityImportEvent & operator=(VisibilityImportEvent const &);
50172  public:
50173  VisibilityImportEvent();
50174  virtual ~VisibilityImportEvent();
50175  VisibilityImportEvent(HPS::SegmentKey & in_segment_key, HPS::VisibilityKit & in_visibility_kit);
50176 
50177  HPS::SegmentKey & segment_key;
50178  HPS::VisibilityKit & visibility_kit;
50179  };
50180 
50181  class HPS_API VisualEffectsImportEvent : public ImportEvent
50182  {
50184  VisualEffectsImportEvent & operator=(VisualEffectsImportEvent const &);
50185  public:
50186  VisualEffectsImportEvent();
50187  virtual ~VisualEffectsImportEvent();
50188  VisualEffectsImportEvent(HPS::SegmentKey & in_segment_key, HPS::VisualEffectsKit & in_visual_effects_kit);
50189 
50190  HPS::SegmentKey & segment_key;
50191  HPS::VisualEffectsKit & visual_effects_kit;
50192  };
50193 
50195 
50196 
50198  class HPS_API ImportOptionsKit : public Kit
50199  {
50200  public:
50202  ImportOptionsKit();
50203 
50206  ImportOptionsKit(ImportOptionsKit const & in_kit);
50207 
50211  ImportOptionsKit(ImportOptionsKit && in_that);
50212 
50216  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
50217 
50218  virtual ~ImportOptionsKit();
50219 
50220  static const HPS::Type staticType = HPS::Type::StreamImportOptionsKit;
50221  HPS::Type ObjectType() const { return staticType; };
50222 
50225  void Set(ImportOptionsKit const & in_kit);
50226 
50229  void Show(ImportOptionsKit & out_kit) const;
50230 
50234  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
50235 
50238  bool Empty() const;
50239 
50243  bool Equals(ImportOptionsKit const & in_kit) const;
50244 
50248  bool operator==(ImportOptionsKit const & in_kit) const;
50249 
50253  bool operator!=(ImportOptionsKit const & in_kit) const;
50254 
50257  ImportOptionsKit & SetToolkit(Toolkit const & in_toolkit);
50258 
50261  ImportOptionsKit & UnsetToolkit();
50262 
50266  bool ShowToolkit(HPS::Stream::Toolkit & out_toolkit) const;
50267 
50272  ImportOptionsKit & SetSegment(SegmentKey const & in_segment);
50273 
50276  ImportOptionsKit & UnsetSegment();
50277 
50281  bool ShowSegment(SegmentKey & out_segment) const;
50282 
50287  ImportOptionsKit & SetAlternateRoot(SegmentKey const & in_segment);
50288 
50291  ImportOptionsKit & UnsetAlternateRoot();
50292 
50296  bool ShowAlternateRoot(SegmentKey & out_segment) const;
50297 
50302  ImportOptionsKit & SetPortfolio(PortfolioKey const & in_portfolio);
50303 
50306  ImportOptionsKit & UnsetPortfolio();
50307 
50311  bool ShowPortfolio(PortfolioKey & out_portfolio) const;
50312 
50315  ImportOptionsKit & UnsetEverything();
50316 
50321  ImportOptionsKit & SetEventHandler(HPS::Stream::ImportEventHandler & in_handler, intptr_t in_type);
50322 
50326  ImportOptionsKit & UnsetEventHandler(intptr_t in_type);
50327 
50330  ImportOptionsKit & UnsetEventHandlers();
50331  };
50332 
50334  class HPS_API ImportResultsKit : public Kit
50335  {
50336  public:
50338  ImportResultsKit();
50339 
50342  ImportResultsKit(ImportResultsKit const & in_kit);
50343 
50347  ImportResultsKit(ImportResultsKit && in_that);
50348 
50352  ImportResultsKit & operator=(ImportResultsKit && in_that);
50353 
50354  virtual ~ImportResultsKit();
50355 
50356  static const HPS::Type staticType = HPS::Type::StreamImportResultsKit;
50357  HPS::Type ObjectType() const { return staticType; };
50358 
50361  void Set(ImportResultsKit const & in_kit);
50362 
50365  void Show(ImportResultsKit & out_kit) const;
50366 
50370  ImportResultsKit & operator=(ImportResultsKit const & in_kit);
50371 
50374  bool Empty() const;
50375 
50379  bool Equals(ImportResultsKit const & in_kit) const;
50380 
50384  bool operator==(ImportResultsKit const & in_kit) const;
50385 
50389  bool operator!=(ImportResultsKit const & in_kit) const;
50390 
50395  ImportResultsKit & SetSegment(SegmentKey const & in_segment);
50396 
50400  ImportResultsKit & UnsetSegment();
50401 
50406  bool ShowSegment(SegmentKey & out_segment) const;
50407 
50412  ImportResultsKit & SetAlternateRoot(SegmentKey const & in_segment);
50413 
50417  ImportResultsKit & UnsetAlternateRoot();
50418 
50424  bool ShowAlternateRoot(SegmentKey & out_segment) const;
50425 
50430  ImportResultsKit & SetPortfolio(PortfolioKey const & in_portfolio);
50431 
50435  ImportResultsKit & UnsetPortfolio();
50436 
50442  bool ShowPortfolio(PortfolioKey & out_portfolio) const;
50443 
50448  ImportResultsKit & SetDefaultCamera(CameraKit const & in_camera);
50449 
50453  ImportResultsKit & UnsetDefaultCamera();
50454 
50459  bool ShowDefaultCamera(CameraKit & out_camera) const;
50460 
50461 
50467  ImportResultsKit & SetAlternateCameras(UTF8Array const & in_names, CameraKitArray & in_cameras);
50468 
50472  ImportResultsKit & UnsetAlternateCameras();
50473 
50478  bool ShowAlternateCameras(UTF8Array & out_names, CameraKitArray & out_cameras) const;
50479 
50480 
50483  ImportResultsKit & UnsetEverything();
50484  };
50485 
50487  class HPS_API ExportOptionsKit : public Kit
50488  {
50489  public:
50491  ExportOptionsKit();
50492 
50495  ExportOptionsKit(ExportOptionsKit const & in_kit);
50496 
50500  ExportOptionsKit(ExportOptionsKit && in_that);
50501 
50505  ExportOptionsKit & operator=(ExportOptionsKit && in_that);
50506 
50510  static ExportOptionsKit GetDefault();
50511 
50512  virtual ~ExportOptionsKit();
50513 
50514  static const HPS::Type staticType = HPS::Type::StreamExportOptionsKit;
50515  HPS::Type ObjectType() const { return staticType; };
50516 
50519  void Set(ExportOptionsKit const & in_kit);
50520 
50523  void Show(ExportOptionsKit & out_kit) const;
50524 
50528  ExportOptionsKit & operator=(ExportOptionsKit const & in_kit);
50529 
50532  bool Empty() const;
50533 
50537  bool Equals(ExportOptionsKit const & in_kit) const;
50538 
50542  bool operator==(ExportOptionsKit const & in_kit) const;
50543 
50547  bool operator!=(ExportOptionsKit const & in_kit) const;
50548 
50551  ExportOptionsKit & SetToolkit(Toolkit const & in_toolkit);
50552 
50556  ExportOptionsKit & SetDefaultCamera(CameraKit const & in_camera);
50557 
50565  ExportOptionsKit & SetVertexCompression(bool in_state, unsigned int in_bits_per_vertex = 24);
50566 
50574  ExportOptionsKit & SetNormalCompression(bool in_state, unsigned int in_bits_per_normal = 10);
50575 
50581  ExportOptionsKit & SetParameterCompression(bool in_state, unsigned int in_bits_per_parameter = 8);
50582 
50590  ExportOptionsKit & SetColorCompression(bool in_state, unsigned int in_bits_per_color = 24);
50591 
50599  ExportOptionsKit & SetIndexCompression(bool in_state, unsigned int in_bits_per_index = 8);
50600 
50606  ExportOptionsKit & SetConnectivityCompression(bool in_state);
50607 
50613  ExportOptionsKit & SetSerializeTristrips(bool in_state);
50614 
50623  ExportOptionsKit & SetImageCompression(bool in_state, float in_quality = 0.75f);
50624 
50627  ExportOptionsKit & UnsetToolkit();
50628 
50631  ExportOptionsKit & UnsetDefaultCamera();
50632 
50635  ExportOptionsKit & UnsetVertexCompression();
50636 
50639  ExportOptionsKit & UnsetNormalCompression();
50640 
50643  ExportOptionsKit & UnsetParameterCompression();
50644 
50647  ExportOptionsKit & UnsetColorCompression();
50648 
50651  ExportOptionsKit & UnsetIndexCompression();
50652 
50655  ExportOptionsKit & UnsetConnectivityCompression();
50656 
50659  ExportOptionsKit & UnsetImageCompression();
50660 
50663  ExportOptionsKit & UnsetSerializeTristrips();
50664 
50667  ExportOptionsKit & UnsetEverything();
50668 
50672  bool ShowToolkit(HPS::Stream::Toolkit & out_toolkit) const;
50673 
50677  bool ShowDefaultCamera(CameraKit & out_camera) const;
50678 
50683  bool ShowVertexCompression(bool & out_state, unsigned int & out_bits_per_vertex) const;
50684 
50689  bool ShowNormalCompression(bool & out_state, unsigned int & out_bits_per_normal) const;
50690 
50695  bool ShowParameterCompression(bool & out_state, unsigned int & out_bits_per_parameter) const;
50696 
50701  bool ShowColorCompression(bool & out_state, unsigned int & out_bits_per_color) const;
50702 
50707  bool ShowIndexCompression(bool & out_state, unsigned int & out_bits_per_index) const;
50708 
50712  bool ShowConnectivityCompression(bool & out_state) const;
50713 
50718  bool ShowImageCompression(bool & out_state, float & out_quality) const;
50719 
50723  bool ShowSerializeTristrips(bool & out_state) const;
50724 
50729  ExportOptionsKit & SetEventHandler(HPS::Stream::ExportEventHandler & in_handler, intptr_t in_type);
50730 
50734  ExportOptionsKit & UnsetEventHandler(intptr_t in_type);
50735 
50738  ExportOptionsKit & UnsetEventHandlers();
50739  };
50740 
50743  class HPS_API ImportNotifier : public IONotifier
50744  {
50745  public:
50747  ImportNotifier();
50748 
50751  ImportNotifier(ImportNotifier const & in_that);
50752 
50757  ImportNotifier(IONotifier const & in_that);
50758 
50762  ImportNotifier(ImportNotifier && in_that);
50763 
50767  ImportNotifier & operator=(ImportNotifier && in_that);
50768 
50769  virtual ~ImportNotifier();
50770 
50771  static const HPS::Type staticType = HPS::Type::StreamImportNotifier;
50772  HPS::Type ObjectType() const {return staticType;};
50773 
50777  ImportNotifier & operator=(ImportNotifier const & in_that);
50778 
50781  void Assign(ImportNotifier const & in_that);
50782 
50786  ImportResultsKit GetResults() const;
50787  };
50788 
50791  class HPS_API ExportNotifier : public IONotifier
50792  {
50793  public:
50795  ExportNotifier();
50796 
50799  ExportNotifier(ExportNotifier const & in_that);
50800 
50805  ExportNotifier(IONotifier const & in_that);
50806 
50810  ExportNotifier(ExportNotifier && in_that);
50811 
50815  ExportNotifier & operator=(ExportNotifier && in_that);
50816 
50817  virtual ~ExportNotifier();
50818 
50819  static const HPS::Type staticType = HPS::Type::StreamExportNotifier;
50820  HPS::Type ObjectType() const {return staticType;};
50821 
50825  ExportNotifier & operator=(ExportNotifier const & in_that);
50826 
50829  void Assign(ExportNotifier const & in_that);
50830  };
50831 
50832 
50834  class HPS_API File
50835  {
50836  public:
50842  static ImportNotifier Import(char const * in_file_name, ImportOptionsKit const & in_options);
50843 
50849  static ImportNotifier Import(ByteArrayArray const & in_hsf_buffers, ImportOptionsKit const & in_options);
50850 
50857  static ExportNotifier Export(char const * in_file_name, SegmentKey const & in_segment, ExportOptionsKit const & in_options);
50858 
50865  static ExportNotifier Export(SegmentKey const & in_segment, ExportOptionsKit const & in_options, ByteArrayArray & out_hsf_buffers);
50866 
50867  private:
50869  File();
50870  };
50871 private:
50873  Stream();
50874 };
50875 
50879 
50884 class HPS_API Hardcopy
50885 {
50886 public:
50887 
50889  enum class SizeUnits : uint32_t
50890  {
50891  Centimeters,
50892  Inches,
50893  };
50894 
50896  enum class ResolutionUnits : uint32_t
50897  {
50898  DPCM,
50899  DPI,
50900  DotsPerCentimeter = DPCM,
50901  DotsPerInch = DPI,
50902  };
50903 
50905  enum class BackgroundPreference : uint32_t
50906  {
50907  UseBackgroundColor,
50908  ForceSolidWhite,
50909  };
50910 
50912  enum class RenderingAlgorithm : uint32_t
50913  {
50914  TwoPassPrint,
50915  SinglePassPrint,
50916  };
50917 
50919  class HPS_API File
50920  {
50921  public:
50922 
50924  class HPS_API ExportOptionsKit : public Kit
50925  {
50926  public:
50928  ExportOptionsKit();
50929 
50932  ExportOptionsKit(ExportOptionsKit const & in_kit);
50933 
50937  ExportOptionsKit(ExportOptionsKit && in_that);
50938 
50942  ExportOptionsKit & operator=(ExportOptionsKit && in_that);
50943 
50944  virtual ~ExportOptionsKit();
50945 
50946  static const HPS::Type staticType = HPS::Type::HardcopyExportOptionsKit;
50947  HPS::Type ObjectType() const { return staticType; };
50948 
50951  void Set(ExportOptionsKit const & in_kit);
50952 
50955  void Show(ExportOptionsKit & out_kit) const;
50956 
50960  ExportOptionsKit & operator=(ExportOptionsKit const & in_kit);
50961 
50964  bool Empty() const;
50965 
50969  bool Equals(ExportOptionsKit const & in_kit) const;
50970 
50974  bool operator==(ExportOptionsKit const & in_kit) const;
50975 
50979  bool operator!=(ExportOptionsKit const & in_kit) const;
50980 
50981 
50982 
50983 
50989  bool ShowSize(float & out_width, float & out_height, Hardcopy::SizeUnits & out_units) const;
50990 
50998  ExportOptionsKit & SetSize(float in_width, float in_height, Hardcopy::SizeUnits in_units = Hardcopy::SizeUnits::Inches);
50999 
51002  ExportOptionsKit & UnsetSize();
51003 
51004 
51005 
51011  bool ShowResolution(float & out_resolution, Hardcopy::ResolutionUnits & out_units) const;
51012 
51019  ExportOptionsKit & SetResolution(float in_resolution, Hardcopy::ResolutionUnits in_units = Hardcopy::ResolutionUnits::DPI);
51020 
51023  ExportOptionsKit & UnsetResolution();
51024 
51030  bool ShowHiddenLineSorting(bool & out_state, float & out_threshold, HPS::Line::SizeUnits & out_units) const;
51031 
51041  ExportOptionsKit & SetHiddenLineSorting(bool in_on, float in_activation_weight = 2.0f, HPS::Line::SizeUnits in_units = HPS::Line::SizeUnits::Pixels);
51042 
51045  ExportOptionsKit & UnsetHiddenLineSorting();
51046 
51047 
51051  bool ShowWYSIWYG(bool & out_onoff) const;
51052 
51064  ExportOptionsKit & SetWYSIWYG(bool in_onoff);
51065 
51068  ExportOptionsKit & UnsetWYSIWYG();
51069 
51074  bool ShowScale(float & out_scale, HPS::Hardcopy::SizeUnits & out_units) const;
51075 
51085  ExportOptionsKit & SetScale(float in_scale, Hardcopy::SizeUnits in_units = Hardcopy::SizeUnits::Inches);
51086 
51089  ExportOptionsKit & UnsetScale();
51090 
51094  bool ShowBackgroundPreference(Hardcopy::BackgroundPreference & out_background_preference) const;
51095 
51100  ExportOptionsKit & SetBackgroundPreference(Hardcopy::BackgroundPreference in_background_preference);
51101 
51104  ExportOptionsKit & UnsetBackgroundPreference();
51105 
51106 
51110  bool ShowRenderingAlgorithm(Hardcopy::RenderingAlgorithm & out_rendering_algorithm) const;
51111 
51116  ExportOptionsKit & SetRenderingAlgorithm(Hardcopy::RenderingAlgorithm in_rendering_algorithm);
51117 
51120  ExportOptionsKit & UnsetRenderingAlgorithm();
51121 
51122 
51125  ExportOptionsKit & UnsetEverything();
51126 
51127 
51131  static ExportOptionsKit GetDefault();
51132  };
51133 
51135  enum class Driver : uint32_t
51136  {
51137  PDF,
51138  Postscript
51139  };
51140 
51146  static IOResult Export(char const * in_filename, Driver in_driver_type, HPS::WindowKey const & in_window, ExportOptionsKit const & in_options);
51147  private:
51148  File();
51149  };
51150 
51151 #ifdef _MSC_VER
51152  class HPS_API GDI
51153  {
51154  public:
51155 
51157  class HPS_API ExportOptionsKit : public Kit
51158  {
51159  public:
51161  ExportOptionsKit();
51162 
51165  ExportOptionsKit(ExportOptionsKit const & in_kit);
51166 
51170  ExportOptionsKit(ExportOptionsKit && in_that);
51171 
51175  ExportOptionsKit & operator=(ExportOptionsKit && in_that);
51176 
51177  virtual ~ExportOptionsKit();
51178 
51179  static const HPS::Type staticType = HPS::Type::HardcopyGDIExportOptionsKit;
51180  HPS::Type ObjectType() const { return staticType; };
51181 
51184  void Set(ExportOptionsKit const & in_kit);
51185 
51188  void Show(ExportOptionsKit & out_kit) const;
51189 
51193  ExportOptionsKit & operator=(ExportOptionsKit const & in_kit);
51194 
51197  bool Empty() const;
51198 
51202  bool Equals(ExportOptionsKit const & in_kit) const;
51203 
51207  bool operator==(ExportOptionsKit const & in_kit) const;
51208 
51212  bool operator!=(ExportOptionsKit const & in_kit) const;
51213 
51214 
51219  bool ShowSize(float & out_width, float & out_height) const;
51220 
51225  ExportOptionsKit & SetSize(float in_width, float in_height);
51226 
51229  ExportOptionsKit & UnsetSize();
51230 
51231 
51235  bool ShowResolution(float & out_resolution) const;
51236 
51240  ExportOptionsKit & SetResolution(float in_resolution);
51241 
51244  ExportOptionsKit & UnsetResolution();
51245 
51251  bool ShowHiddenLineSorting(bool & out_state, float & out_threshold, HPS::Line::SizeUnits & out_units) const;
51252 
51262  ExportOptionsKit & SetHiddenLineSorting(bool in_on, float in_activation_weight = 2.0f, HPS::Line::SizeUnits in_units = HPS::Line::SizeUnits::Pixels);
51263 
51266  ExportOptionsKit & UnsetHiddenLineSorting();
51267 
51270  bool ShowWYSIWYG(bool & out_onoff) const;
51271 
51275  ExportOptionsKit & SetWYSIWYG(bool in_onoff);
51276 
51279  ExportOptionsKit & UnsetWYSIWYG();
51280 
51285  bool ShowScale(float & out_scale, HPS::Hardcopy::SizeUnits & out_units) const;
51286 
51296  ExportOptionsKit & SetScale(float in_scale, Hardcopy::SizeUnits in_units = Hardcopy::SizeUnits::Inches);
51297 
51300  ExportOptionsKit & UnsetScale();
51301 
51305  bool ShowBackgroundPreference(Hardcopy::BackgroundPreference & out_background_preference) const;
51306 
51311  ExportOptionsKit & SetBackgroundPreference(Hardcopy::BackgroundPreference in_background_preference);
51312 
51315  ExportOptionsKit & UnsetBackgroundPreference();
51316 
51317 
51321  bool ShowRenderingAlgorithm(Hardcopy::RenderingAlgorithm & out_rendering_algorithm) const;
51322 
51327  ExportOptionsKit & SetRenderingAlgorithm(Hardcopy::RenderingAlgorithm in_rendering_algorithm);
51328 
51331  ExportOptionsKit & UnsetRenderingAlgorithm();
51332 
51333 
51336  ExportOptionsKit & UnsetEverything();
51337  };
51338 
51345  static IOResult Export(intptr_t in_hdc, intptr_t in_attribdc, HPS::WindowKey const & in_window, ExportOptionsKit const & in_options);
51346 
51351  static IOResult ExportClipboard(HPS::WindowKey const & in_window, ExportOptionsKit const & in_options);
51352 
51358  static IOResult ExportEMF(char const * in_filename, WindowKey const & in_window, ExportOptionsKit const & in_options);
51359 
51360  private:
51361  GDI();
51362  };
51363 #endif
51364 
51365 private:
51366  Hardcopy();
51367 };
51368 
51372 
51374 class HPS_API OBJ
51375 {
51376 public:
51377 
51379  class HPS_API ImportOptionsKit : public Kit
51380  {
51381  public:
51383  ImportOptionsKit();
51384 
51387  ImportOptionsKit(ImportOptionsKit const & in_kit);
51388 
51392  ImportOptionsKit(ImportOptionsKit && in_that);
51393 
51397  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
51398 
51399  virtual ~ImportOptionsKit();
51400 
51401  static const HPS::Type staticType = HPS::Type::OBJImportOptionsKit;
51402  HPS::Type ObjectType() const { return staticType; };
51403 
51406  void Set(ImportOptionsKit const & in_kit);
51407 
51410  void Show(ImportOptionsKit & out_kit) const;
51411 
51415  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
51416 
51419  bool Empty() const;
51420 
51424  bool Equals(ImportOptionsKit const & in_kit) const;
51425 
51429  bool operator==(ImportOptionsKit const & in_kit) const;
51430 
51434  bool operator!=(ImportOptionsKit const & in_kit) const;
51435 
51440  ImportOptionsKit & SetSegment(SegmentKey const & in_segment);
51441 
51444  ImportOptionsKit & UnsetSegment();
51445 
51449  bool ShowSegment(SegmentKey & out_segment) const;
51450 
51455  ImportOptionsKit & SetPortfolio(PortfolioKey const & in_portfolio);
51456 
51459  ImportOptionsKit & UnsetPortfolio();
51460 
51464  bool ShowPortfolio(PortfolioKey & out_portfolio) const;
51465 
51471  ImportOptionsKit & SetHandedness(Drawing::Handedness const & in_handedness);
51472 
51475  ImportOptionsKit & UnsetHandedness();
51476 
51480  bool ShowHandedness(Drawing::Handedness & out_handedness) const;
51481 
51484  ImportOptionsKit & UnsetEverything();
51485  };
51486 
51488  class HPS_API ImportResultsKit : public Kit
51489  {
51490  public:
51492  ImportResultsKit();
51493 
51496  ImportResultsKit(ImportResultsKit const & in_kit);
51497 
51501  ImportResultsKit(ImportResultsKit && in_that);
51502 
51506  ImportResultsKit & operator=(ImportResultsKit && in_that);
51507 
51508  virtual ~ImportResultsKit();
51509 
51510  static const HPS::Type staticType = HPS::Type::OBJImportResultsKit;
51511  HPS::Type ObjectType() const { return staticType; };
51512 
51515  void Set(ImportResultsKit const & in_kit);
51516 
51519  void Show(ImportResultsKit & out_kit) const;
51520 
51524  ImportResultsKit & operator=(ImportResultsKit const & in_kit);
51525 
51528  bool Empty() const;
51529 
51533  bool Equals(ImportResultsKit const & in_kit) const;
51534 
51538  bool operator==(ImportResultsKit const & in_kit) const;
51539 
51543  bool operator!=(ImportResultsKit const & in_kit) const;
51544 
51549  ImportResultsKit & SetSegment(SegmentKey const & in_segment);
51550 
51554  ImportResultsKit & UnsetSegment();
51555 
51560  bool ShowSegment(SegmentKey & out_segment) const;
51561 
51566  ImportResultsKit & SetPortfolio(PortfolioKey const & in_portfolio);
51567 
51571  ImportResultsKit & UnsetPortfolio();
51572 
51578  bool ShowPortfolio(PortfolioKey & out_portfolio) const;
51579 
51584  ImportResultsKit & SetHandedness(Drawing::Handedness const & in_handedness);
51585 
51589  ImportResultsKit & UnsetHandedness();
51590 
51595  bool ShowHandedness(Drawing::Handedness & out_handedness) const;
51596 
51599  ImportResultsKit & UnsetEverything();
51600  };
51601 
51604  class HPS_API ImportNotifier : public IONotifier
51605  {
51606  public:
51608  ImportNotifier();
51609 
51612  ImportNotifier(ImportNotifier const & in_that);
51613 
51618  ImportNotifier(IONotifier const & in_that);
51619 
51623  ImportNotifier(ImportNotifier && in_that);
51624 
51628  ImportNotifier & operator=(ImportNotifier && in_that);
51629 
51630  virtual ~ImportNotifier();
51631 
51632  static const HPS::Type staticType = HPS::Type::OBJImportNotifier;
51633  HPS::Type ObjectType() const {return staticType;};
51634 
51638  ImportNotifier & operator=(ImportNotifier const & in_that);
51639 
51642  void Assign(ImportNotifier const & in_that);
51643 
51647  ImportResultsKit GetResults() const;
51648  };
51649 
51652  class HPS_API ExportNotifier : public IONotifier
51653  {
51654  public:
51656  ExportNotifier();
51657 
51660  ExportNotifier(ExportNotifier const & in_that);
51661 
51666  ExportNotifier(IONotifier const & in_that);
51667 
51671  ExportNotifier(ExportNotifier && in_that);
51672 
51676  ExportNotifier & operator=(ExportNotifier && in_that);
51677 
51678  virtual ~ExportNotifier();
51679 
51680  static const HPS::Type staticType = HPS::Type::OBJExportNotifier;
51681  HPS::Type ObjectType() const { return staticType; };
51682 
51686  ExportNotifier & operator=(ExportNotifier const & in_that);
51687 
51690  void Assign(ExportNotifier const & in_that);
51691  };
51692 
51693 
51695  class HPS_API File
51696  {
51697  public:
51703  static ImportNotifier Import(char const * in_file_name, ImportOptionsKit const & in_options);
51704 
51711  static ExportNotifier Export(char const * in_file_name, HPS::KeyPath const & in_key_path_to_export);
51712 
51713  private:
51715  File();
51716  };
51717 private:
51719  OBJ();
51720 };
51721 
51725 
51727 class HPS_API STL
51728 {
51729 public:
51730 
51732  class HPS_API ImportOptionsKit : public Kit
51733  {
51734  public:
51736  ImportOptionsKit();
51737 
51740  ImportOptionsKit(ImportOptionsKit const & in_kit);
51741 
51745  ImportOptionsKit(ImportOptionsKit && in_that);
51746 
51750  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
51751 
51752  virtual ~ImportOptionsKit();
51753 
51754  static const HPS::Type staticType = HPS::Type::STLImportOptionsKit;
51755  HPS::Type ObjectType() const { return staticType; };
51756 
51759  void Set(ImportOptionsKit const & in_kit);
51760 
51763  void Show(ImportOptionsKit & out_kit) const;
51764 
51768  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
51769 
51772  bool Empty() const;
51773 
51777  bool Equals(ImportOptionsKit const & in_kit) const;
51778 
51782  bool operator==(ImportOptionsKit const & in_kit) const;
51783 
51787  bool operator!=(ImportOptionsKit const & in_kit) const;
51788 
51792  static ImportOptionsKit GetDefault();
51793 
51798  ImportOptionsKit & SetSegment(SegmentKey const & in_segment);
51799 
51807  ImportOptionsKit & SetOptimization(bool in_state, ShellOptimizationOptionsKit const & in_optimization_kit);
51808 
51815  ImportOptionsKit & SetOptimization(ShellOptimizationOptionsKit const & in_optimization_kit);
51816 
51817 
51820  ImportOptionsKit & UnsetSegment();
51821 
51824  ImportOptionsKit & UnsetOptimization();
51825 
51828  ImportOptionsKit & UnsetEverything();
51829 
51830 
51834  bool ShowSegment(SegmentKey & out_segment) const;
51835 
51840  bool ShowOptimization(bool & out_state, ShellOptimizationOptionsKit & out_optimization_options) const;
51841  };
51842 
51844  class HPS_API ImportResultsKit : public Kit
51845  {
51846  public:
51848  ImportResultsKit();
51849 
51852  ImportResultsKit(ImportResultsKit const & in_kit);
51853 
51857  ImportResultsKit(ImportResultsKit && in_that);
51858 
51862  ImportResultsKit & operator=(ImportResultsKit && in_that);
51863 
51864  virtual ~ImportResultsKit();
51865 
51866  static const HPS::Type staticType = HPS::Type::STLImportResultsKit;
51867  HPS::Type ObjectType() const { return staticType; };
51868 
51871  void Set(ImportResultsKit const & in_kit);
51872 
51875  void Show(ImportResultsKit & out_kit) const;
51876 
51880  ImportResultsKit & operator=(ImportResultsKit const & in_kit);
51881 
51884  bool Empty() const;
51885 
51889  bool Equals(ImportResultsKit const & in_kit) const;
51890 
51894  bool operator==(ImportResultsKit const & in_kit) const;
51895 
51899  bool operator!=(ImportResultsKit const & in_kit) const;
51900 
51905  ImportResultsKit & SetSegment(SegmentKey const & in_segment);
51906 
51910  ImportResultsKit & UnsetSegment();
51911 
51916  bool ShowSegment(SegmentKey & out_segment) const;
51917 
51920  ImportResultsKit & UnsetEverything();
51921  };
51922 
51925  class HPS_API ImportNotifier : public IONotifier
51926  {
51927  public:
51929  ImportNotifier();
51930 
51933  ImportNotifier(ImportNotifier const & in_that);
51934 
51939  ImportNotifier(IONotifier const & in_that);
51940 
51944  ImportNotifier(ImportNotifier && in_that);
51945 
51949  ImportNotifier & operator=(ImportNotifier && in_that);
51950 
51951  virtual ~ImportNotifier();
51952 
51953  static const HPS::Type staticType = HPS::Type::STLImportNotifier;
51954  HPS::Type ObjectType() const {return staticType;};
51955 
51959  ImportNotifier & operator=(ImportNotifier const & in_that);
51960 
51963  void Assign(ImportNotifier const & in_that);
51964 
51968  ImportResultsKit GetResults() const;
51969  };
51970 
51971 
51973  class HPS_API File
51974  {
51975  public:
51981  static ImportNotifier Import(char const * in_file_name, ImportOptionsKit const & in_options);
51982 
51983  private:
51985  File();
51986  };
51987 private:
51989  STL();
51990 };
51991 
51992 }
51993 
51994 #ifdef _MSC_VER
51995 # pragma warning(pop)
51996 #endif
51997 
51998 #endif
51999 
52000 
HPS::Type ObjectType() const
Definition: hps.h:46298
HPS::Type ObjectType() const
Definition: hps.h:29736
bool Empty() const
Definition: hps.h:7201
CameraPoint(Point const &in_point)
Definition: hps.h:6144
HPS::Type ObjectType() const
Definition: hps.h:21486
WindowPoint Location
Location in window space of the mouse cursor.
Definition: hps.h:48341
Definition: hps.h:3420
Definition: hps.h:6261
virtual bool Equals(InputEvent const &in_that) const
Definition: hps.h:48284
HPS::Type ObjectType() const
Definition: hps.h:26877
Material Texture ChannelMapping.
std::vector< WindowKey, Allocator< WindowKey > > WindowKeyArray
Array of type HPS::WindowKey.
Definition: hps.h:6690
Definition: hps.h:15648
Definition: hps.h:1068
Definition: hps.h:13044
HPS::Type ObjectType() const
Definition: hps.h:18937
bool HasAll(MouseButtons const &in_buttons) const
Definition: hps.h:48117
HPS::Type ObjectType() const
Definition: hps.h:40683
Event(intptr_t in_channel=0)
Definition: hps.h:6359
bool Equals(TouchEvent const &in_that) const
Definition: hps.h:47994
Definition: hps.h:20100
HPS::Type ObjectType() const
Definition: hps.h:51633
Cuboid_3D(Point_3D< F > const &in_min, Point_3D< F > const &in_max)
Definition: hps.h:3927
HPS::ByteArray user_data
Definition: hps.h:50148
void ScrollLock(bool in_state)
Definition: hps.h:47697
float alpha
Definition: hps.h:4545
Definition: hps.h:38824
std::vector< Search::Type, Allocator< Search::Type > > SearchTypeArray
Array of type HPS::Search::Type.
Definition: hps.h:6710
HPS::Type ObjectType() const
Definition: hps.h:40281
bool operator==(Touch const &in_that) const
Definition: hps.h:6649
void X1(bool in_state)
Definition: hps.h:48138
virtual HPS::Type Type() const
Definition: hps.h:23265
Search for all attributes, geometry, segments, includes and includers.
void RightMeta(bool in_state)
Definition: hps.h:47725
size_t statics_created_count
Number of static models that were created during the last update.
Definition: hps.h:5079
void Shift(bool in_state)
Definition: hps.h:47673
HPS::Info::Code code
The error code for this ErrorEvent.
Definition: hps.h:47262
size_t display_list_tristrip_count
Number of tristrips drawn from display lists during the last update.
Definition: hps.h:5069
HPS::Type ObjectType() const
Definition: hps.h:38449
Definition: hps.h:9142
HPS::Type ObjectType() const
Definition: hps.h:24327
virtual HPS::Type Type() const
Definition: hps.h:10092
HPS::Type ObjectType() const
Definition: hps.h:26402
size_t extent_culled_segment_count
Number of segments culled because of extent culling during the last update.
Definition: hps.h:5075
HPS::Type ObjectType() const
Definition: hps.h:27153
Definition: hps.h:49274
Definition: hps.h:23058
Definition: sprk_exchange.h:44
Definition: hps.h:46104
void CapsLock(bool in_state)
Definition: hps.h:47689
HPS::Type ObjectType() const
Definition: hps.h:16442
virtual bool Equals(StandAloneWindowEvent const &in_that) const
Definition: hps.h:47317
HPS::Type ObjectType() const
Definition: hps.h:9033
HPS::Type ObjectType() const
Definition: hps.h:31070
Definition: hps.h:49532
Event * Clone() const
Definition: hps.h:47160
Definition: hps.h:14553
Orientation
Definition: hps.h:537
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:48248
Definition: hps.h:51374
virtual HandleResult Handle(Event const *in_event)
Definition: hps.h:46948
ImportStatusEvent()
Definition: hps.h:47472
HPS::Type ObjectType() const
Definition: hps.h:23932
HPS::Type ObjectType() const
Definition: hps.h:40459
Parameterization
Definition: hps.h:962
std::vector< LinePatternDefinition, Allocator< LinePatternDefinition > > LinePatternDefinitionArray
Array of type HPS::LinePatternDefinition.
Definition: hps.h:6720
Definition: hps.h:15163
HPS::Type ObjectType() const
Definition: hps.h:28678
Definition: hps.h:49202
size_t frustum_culled_segment_count
Number of segments culled because of frustum culling during the last update.
Definition: hps.h:5074
LeaderLineSpace
Definition: hps.h:1717
HPS::Type ObjectType() const
Definition: hps.h:33478
std::vector< ShaderDefinition, Allocator< ShaderDefinition > > ShaderDefinitionArray
Array of type HPS::ShaderDefinition.
Definition: hps.h:6721
HPS::Type ObjectType() const
Definition: hps.h:28288
HPS::Type ObjectType() const
Definition: hps.h:12567
static MouseButtons ButtonX2()
Definition: hps.h:48193
Definition: hps.h:21941
Definition: hps.h:17330
Type
Definition: hps.h:268
Fill
Definition: hps.h:2025
Search the current segment only.
void SetKeyboardCodes(size_t in_keyboardcode_count, HPS::KeyboardCode const in_keyboardcodes[])
Definition: hps.h:48457
Definition: hps.h:51844
Definition: hps.h:43156
Definition: hps.h:21243
HPS::Type ObjectType() const
Definition: hps.h:42973
ObjectPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:6057
HPS::Type ObjectType() const
Definition: hps.h:39518
Definition: hps.h:49842
Transform
Definition: hps.h:1602
InnerWindowPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:6183
Behavior
Definition: hps.h:588
bool Middle() const
Definition: hps.h:48103
DisplayLists
Definition: hps.h:1111
Definition: hps.h:472
HPS::Type ObjectType() const
Definition: hps.h:48498
static HPS_INLINE bool IsInfinite(float const &a)
Definition: hps.h:2396
Modifier
Definition: hps.h:1961
Definition: hps.h:39751
HPS::Type ObjectType() const
Definition: hps.h:44748
Definition: hps.h:48349
virtual void Handle(DriverEvent const *in_event)
Definition: hps.h:9158
HPS::Type ObjectType() const
Definition: hps.h:26127
HPS::Type ObjectType() const
Definition: hps.h:40208
std::vector< LinePatternElement, Allocator< LinePatternElement > > LinePatternElementArray
Array of type HPS::LinePatternElement.
Definition: hps.h:6707
Definition: hps.h:10069
Overlay
Definition: hps.h:1304
HPS::Type ObjectType() const
Definition: hps.h:13951
size_t dot_3d_count
Number of 3D dots drawn during the last update.
Definition: hps.h:5057
HPS::Type ObjectType() const
Definition: hps.h:48611
HPS::Type ObjectType() const
Definition: hps.h:22895
Definition: hps.h:49786
std::vector< SegmentKey, Allocator< SegmentKey > > SegmentKeyArray
Array of type HPS::SegmentKey.
Definition: hps.h:6689
static ModifierKeys KeyLeftMeta()
Definition: hps.h:47824
Definition: hps.h:29308
HPS::Type ObjectType() const
Definition: hps.h:15189
InputEvent()
Definition: hps.h:47861
An InvalidSpecificationException is thrown when a method is called with non-sensical or contradictory...
Definition: hps.h:5865
HPS::UTF8 text
The text for this TextInputEvent.
Definition: hps.h:47423
virtual HPS::Type Type() const
Definition: hps.h:19525
ClipSpace
Definition: hps.h:1334
virtual HPS::Type Type() const
Definition: hps.h:12142
Definition: hps.h:40903
virtual HPS::Type Type() const
Definition: hps.h:21266
Definition: hps.h:39717
bool ScrollLock() const
Definition: hps.h:47626
static MouseButtons ButtonRight()
Definition: hps.h:48181
std::vector< CameraKit, Allocator< CameraKit > > CameraKitArray
Array of type HPS::CameraKit.
Definition: hps.h:6712
virtual HPS::Type Type() const
Definition: hps.h:13200
Definition: hps.h:2253
HPS::Type ObjectType() const
Definition: hps.h:31960
HPS_INLINE bool Intersecting(int dimension, Cuboid_3D const &cuboid) const
Definition: hps.h:4051
Definition: hps.h:5905
RenderingAlgorithm
Definition: hps.h:285
Definition: hps.h:40041
KeyboardEvent(KeyboardEvent::Action in_action, KeyboardCodeArray const &in_keyboardcodes, ModifierKeys in_modifiers=ModifierKeys())
Definition: hps.h:48386
static ModifierKeys KeyMeta()
Definition: hps.h:47780
HPS::Type ObjectType() const
Definition: hps.h:39921
Definition: hps.h:1546
Definition: hps.h:26293
The clip region is specified in world coordinated.
HPS::Type ObjectType() const
Definition: hps.h:42057
Definition: hps.h:18503
std::vector< Vector, Allocator< Vector > > VectorArray
Array of type HPS::Vector.
Definition: hps.h:6680
std::vector< PixelPoint, Allocator< PixelPoint > > PixelPointArray
Array of type HPS::PixelPoint.
Definition: hps.h:6679
HPS::Type ObjectType() const
Definition: hps.h:50820
Definition: hps.h:6837
bool Equals(MouseButtons const &in_that) const
Definition: hps.h:48068
Cuboid_3D(Cuboid_3D< D > const &that)
Definition: hps.h:3913
Definition: hps.h:39249
std::vector< Drawing::Overlay, Allocator< Drawing::Overlay > > DrawingOverlayArray
Array of type HPS::Drawing::Overlay.
Definition: hps.h:6744
HPS::Type ObjectType() const
Definition: hps.h:21728
Decimation
Definition: hps.h:1028
HPS::Type ObjectType() const
Definition: hps.h:44927
Definition: hps.h:48856
Definition: hps.h:43541
HPS::Type ObjectType() const
Definition: hps.h:26326
HPS::Type ObjectType() const
Definition: hps.h:39330
Definition: hps.h:25029
HPS::Type ObjectType() const
Definition: hps.h:18624
MouseButtons()
Definition: hps.h:48063
HPS::Type ObjectType() const
Definition: hps.h:43707
Definition: hps.h:22659
Time GetTimeStamp() const
Definition: hps.h:6381
Definition: hps.h:51973
void Left(bool in_state)
Definition: hps.h:48126
HPS::Type ObjectType() const
Definition: hps.h:48963
HPS::Type ObjectType() const
Definition: hps.h:24999
std::vector< EventHandler, Allocator< EventHandler > > EventHandlerArray
Array of type HPS::EventHandler.
Definition: hps.h:6691
HPS::Type ObjectType() const
Definition: hps.h:26678
Event * Clone() const
Definition: hps.h:46977
static HPS_INLINE Cuboid_3D Invalid()
Definition: hps.h:3979
Definition: hps.h:49339
Kit(Kit &&in_that)
Definition: hps.h:6038
bool HasAny(MouseButtons const &in_buttons) const
Definition: hps.h:48122
Definition: hps.h:40772
The vertex colors applied to faces.
HPS::Type ObjectType() const
Definition: hps.h:38183
OuterConeUnits
Definition: hps.h:478
Definition: hps.h:46455
KeyboardEvent()
Definition: hps.h:48362
HPS::Type ObjectType() const
Definition: hps.h:7713
Definition: hps.h:42939
HPS_INLINE bool Contains(Cuboid_3D const &contained) const
Definition: hps.h:4166
ObjectPoint(Point const &in_point)
Definition: hps.h:6060
HPS::Type ObjectType() const
Definition: hps.h:19528
Definition: hps.h:37629
size_t deferred_sprite_transparent_items
Number of transparent Spriting items deferred.
Definition: hps.h:5084
Definition: hps.h:47537
Definition: hps.h:46208
Definition: hps.h:4626
Definition: hps.h:7008
Definition: hps.h:1346
Definition: hps.h:46998
Definition: hps.h:27120
Point_3D< F > min
Definition: hps.h:3897
SizeUnits
Definition: hps.h:1781
StandAloneWindowEvent(Event const &in_event)
Definition: hps.h:47291
static ModifierKeys KeyAlt()
Definition: hps.h:47775
bool IsConsumable() const
Definition: hps.h:6384
HPS::ByteArray user_data
Definition: hps.h:50165
Definition: hps.h:1064
size_t GetHash() const
Definition: hps.h:1740
size_t line_dc_count
Number of DC lines drawn during the last update.
Definition: hps.h:5058
KeyboardEvent(KeyboardEvent::Action in_action, size_t in_keyboardcode_count, HPS::KeyboardCode const in_keyboardcodes[], ModifierKeys in_modifiers=ModifierKeys())
Definition: hps.h:48375
void RightShift(bool in_state)
Definition: hps.h:47701
HPS::Type ObjectType() const
Definition: hps.h:14579
SizeUnits
Definition: hps.h:1901
DrawingPreference
Definition: hps.h:1521
virtual HPS::Type Type() const
Definition: hps.h:12428
virtual HPS::Type Type() const
Definition: hps.h:11310
Definition: hps.h:16095
Definition: hps.h:2001
void Merge(size_t count, T const *indices, Point_3D< F > const *points)
Definition: hps.h:4149
virtual HPS::Type Type() const
Definition: hps.h:17609
Cuboid_3D(Rectangle const &that)
Definition: hps.h:3967
std::vector< MaterialPaletteDefinition, Allocator< MaterialPaletteDefinition > > MaterialPaletteDefinitionArray
Array of type HPS::MaterialPaletteDefinition.
Definition: hps.h:6718
std::vector< KeyPath, Allocator< KeyPath > > KeyPathArray
Array of type HPS::KeyPath.
Definition: hps.h:6727
Definition: hps.h:26570
Definition: hps.h:21462
HPS::Type ObjectType() const
Definition: hps.h:30244
std::vector< byte, Allocator< byte > > ByteArray
Array of type HPS::byte.
Definition: hps.h:6703
HPS::Type ObjectType() const
Definition: hps.h:21269
char At(size_t in_index) const
Definition: hps.h:7244
Definition: hps.h:6021
Definition: hps.h:46283
StaticModel
Definition: hps.h:1133
Definition: hps.h:4652
bool HasAny(ModifierKeys const &in_keys) const
Definition: hps.h:47668
HPS::Type ObjectType() const
Definition: hps.h:40337
HPS::Type ObjectType() const
Definition: hps.h:7431
Definition: hps.h:125
size_t polygon_dc_count
Number of DC polygons drawn during the last update.
Definition: hps.h:5062
Definition: hps.h:28645
Definition: hps.h:48690
HideKeyboardEvent()
Definition: hps.h:47541
Definition: hps.h:3895
Definition: hps.h:3892
HPS::Type ObjectType() const
Definition: hps.h:18850
std::vector< ShapeElement, Allocator< ShapeElement > > ShapeElementArray
Array of type HPS::ShapeElement.
Definition: hps.h:6693
Definition: hps.h:20694
Definition: hps.h:7768
HPS::Type ObjectType() const
Definition: hps.h:13308
Definition: hps.h:29524
InnerPixelPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:6224
HPS_INLINE bool Intersecting(Point_3D< F > const &point1, Point_3D< F > const &point2) const
Definition: hps.h:4084
void LeftMeta(bool in_state)
Definition: hps.h:47729
static MouseButtons ButtonX1()
Definition: hps.h:48189
UpdateCompletedEvent()
Definition: hps.h:47432
BackgroundTextureFormat
Definition: hps.h:9121
Definition: hps.h:20354
Definition: hps.h:3571
Definition: hps.h:6631
void X2(bool in_state)
Definition: hps.h:48142
std::vector< Material::Type, Allocator< Material::Type > > MaterialTypeArray
Array of type HPS::Material::Type.
Definition: hps.h:6709
HPS::Type ObjectType() const
Definition: hps.h:21024
std::vector< bool, Allocator< bool > > BoolArray
Array of type bool.
Definition: hps.h:6697
SizeUnits
Definition: hps.h:1758
HPS::Type ObjectType() const
Definition: hps.h:46798
size_t culled_display_list_tristrip_count
Number of tristrips from display lists culled during the last update.
Definition: hps.h:5071
HPS::Type ObjectType() const
Definition: hps.h:45025
Definition: hps.h:16417
Definition: hps.h:2107
HPS::Type ObjectType() const
Definition: hps.h:37663
ToleranceUnits
Definition: hps.h:1823
HPS::Type ObjectType() const override
Definition: hps.h:9147
void SetKeyboardCodes(HPS::KeyboardCodeArray const &in_keyboardcodes)
Definition: hps.h:48464
Background
Definition: hps.h:249
HPS::Type ObjectType() const
Definition: hps.h:29628
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:48018
Definition: hps.h:50055
Definition: hps.h:49428
RegionAlignment
Definition: hps.h:1708
HPS::Type ObjectType() const
Definition: hps.h:13801
A unitless linear scaling factor. A value of 2.0 will cause markers to be rendered twice as large...
HPS::Type ObjectType() const
Definition: hps.h:27868
Component
Definition: hps.h:519
Definition: hps.h:445
HPS::Type ObjectType() const
Definition: hps.h:41436
Definition: hps.h:24304
HPS::Info::Code code
The warning code for this WarningEvent.
Definition: hps.h:47191
Definition: sprk_publish.h:42
HPS_INLINE F Volume() const
Definition: hps.h:4021
HPS::Type ObjectType() const
Definition: hps.h:13069
Definition: hps.h:2212
Definition: hps.h:29605
Definition: hps.h:40847
Definition: hps.h:21702
HPS::Type ObjectType() const
Definition: hps.h:38847
Definition: hps.h:2239
Event * Clone() const
Definition: hps.h:47089
HPS::Type ObjectType() const
Definition: hps.h:15674
Definition: hps.h:4901
std::vector< IncludeKey, Allocator< IncludeKey > > IncludeKeyArray
Array of type HPS::IncludeKey.
Definition: hps.h:6728
static ModifierKeys KeyLeftAlt()
Definition: hps.h:47816
Default
Definition: hps.h:2004
HPS::Type ObjectType() const
Definition: hps.h:50515
HPS::Type ObjectType() const
Definition: hps.h:30346
Definition: hps.h:50027
virtual bool Equals(InputEvent const &in_that) const
Definition: hps.h:47984
size_t TapCount
Number of taps for this Touch.
Definition: hps.h:6664
FrameSize
Definition: hps.h:215
Definition: hps.h:23701
Definition: hps.h:4783
HPS::Type ObjectType() const
Definition: hps.h:43093
HPS::Type ObjectType() const
Definition: hps.h:38321
Definition: hps.h:1429
std::vector< Text::MarginUnits, Allocator< Text::MarginUnits > > TextMarginUnitsArray
Array of type HPS::Text::MarginUnits.
Definition: hps.h:6737
Definition: hps.h:19748
Definition: hps.h:884
Definition: hps.h:5891
TouchEvent(Action in_action, TouchArray const &in_touches, ModifierKeys in_modifier=ModifierKeys())
Definition: hps.h:47941
void Merge(size_t count, Point_3D< F > const *points)
Definition: hps.h:4130
Shape
Definition: hps.h:1090
static ModifierKeys KeyScrollLock()
Definition: hps.h:47792
bool HasAll(ModifierKeys const &in_keys) const
Definition: hps.h:47663
Time update_time
Time taken by the last update.
Definition: hps.h:5054
Definition: hps.h:43059
Definition: hps.h:40436
size_t vector_culled_segment_count
Number of segments culled because of vector culling during the last update.
Definition: hps.h:5076
Definition: hps.h:7758
HPS::Type ObjectType() const
Definition: hps.h:25782
virtual bool Equals(KeyboardEvent const &in_that) const
Definition: hps.h:48433
HPS::Type ObjectType() const
Definition: hps.h:23852
std::vector< int32_t, HPS::Allocator< int32_t > > Int32Array
Array of type int32_t.
Definition: hps.h:6742
WarningEvent(Event const &in_event)
Definition: hps.h:47142
Definition: hps.h:42088
Definition: hps.h:51652
HPS::Type ObjectType() const
Definition: hps.h:40938
Definition: hps.h:45628
HPS::Type ObjectType() const
Definition: hps.h:12431
Definition: hps.h:1798
static ModifierKeys KeyShift()
Definition: hps.h:47765
Definition: hps.h:146
HPS::Type ObjectType() const
Definition: hps.h:31684
MaterialPreference
Definition: hps.h:1839
Type
Definition: hps.h:433
bool IsValid() const
Definition: hps.h:7194
Definition: hps.h:22869
std::vector< PointArray, Allocator< PointArray > > PointArrayArray
Array of type HPS::PointArray.
Definition: hps.h:6736
Definition: hps.h:1564
Cuboid_3D()
Definition: hps.h:3905
ErrorEvent(Event const &in_event)
Definition: hps.h:47213
size_t GetWStrLength() const
Definition: hps.h:7223
Mobility
Definition: hps.h:205
Event * Clone() const
Definition: hps.h:47042
HPS::Type ObjectType() const
Definition: hps.h:11976
Definition: hps.h:9012
Definition: hps.h:28116
static void Free(void *in_pointer)
bool X1() const
Definition: hps.h:48107
Definition: hps.h:49086
Definition: hps.h:246
size_t deferred_3d_items_deleted
Number of deferred items deleted during the last update.
Definition: hps.h:5081
Definition: hps.h:47468
Alignment and justification will be defined relative to a screen-facing box around the text...
HPS_INLINE void Merge(Point_3D< F > const &point)
Definition: hps.h:4115
void Meta(bool in_state)
Definition: hps.h:47685
Definition: hps.h:6959
PixelPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:6307
Definition: hps.h:29713
Definition: hps.h:49773
Definition: hps.h:9100
HPS::Type ObjectType() const
Definition: hps.h:16124
HPS_INLINE bool IsValid() const
Definition: hps.h:3972
HPS::Type ObjectType() const
Definition: hps.h:43834
Action action
The action for this StandAloneWindowEvent.
Definition: hps.h:47338
Definition: hps.h:23490
Event * Clone() const
Definition: hps.h:47871
ModifierKeys ModifierKeyState
The modifier keys which are active for this InputEvent.
Definition: hps.h:47910
Definition: hps.h:4725
TimerTickEvent(Event const &in_event)
Definition: hps.h:46967
Definition: hps.h:51488
Definition: hps.h:6052
WindowPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:6266
HPS::Type ObjectType() const
Definition: hps.h:13398
std::vector< ObjectPoint, Allocator< ObjectPoint > > ObjectPointArray
Array of type HPS::ObjectPoint.
Definition: hps.h:6673
Definition: hps.h:13528
HPS::Type ObjectType() const
Definition: hps.h:11491
Definition: hps.h:18825
Definition: hps.h:2336
std::vector< TrimElement, Allocator< TrimElement > > TrimElementArray
Array of type HPS::TrimElement.
Definition: hps.h:6726
HPS::Type ObjectType() const
Definition: hps.h:43564
Definition: hps.h:27571
HPS::Type ObjectType() const
Definition: hps.h:17355
InformationEvent()
Definition: hps.h:47058
KeyPath & PushBack(Key const &in_key)
bool Equals(GlyphPoint const &in_that) const
Definition: hps.h:5341
Definition: hps.h:42890
Definition: hps.h:12542
Definition: hps.h:47508
Definition: hps.h:15252
size_t triangle_3d_count
Number of 3D triangles drawn during the last update.
Definition: hps.h:5061
Definition: hps.h:11951
Infinite line which extends infinitely in both directions along a vector.
Definition: hps.h:51925
bool Shift() const
Definition: hps.h:47602
HPS::Type ObjectType() const
Definition: hps.h:43959
Definition: hps.h:1858
HPS_INLINE bool Contains(Point_3D< F > const &contained, F epsilon) const
Definition: hps.h:4195
Definition: hps.h:49733
virtual HPS::Type Type() const
Definition: hps.h:23513
Point_3D< F > max
Definition: hps.h:3899
HPS::Type ObjectType() const
Definition: hps.h:7797
Definition: hps.h:12260
Definition: hps.h:23242
Definition: hps.h:15375
HPS::Type ObjectType() const
Definition: hps.h:51402
HPS::Type ObjectType() const
Definition: hps.h:51511
MouseEvent()
Definition: hps.h:48230
Definition: hps.h:15470
bool LeftShift() const
Definition: hps.h:47634
HPS::Type ObjectType() const
Definition: hps.h:13203
static ModifierKeys KeyLeftControl()
Definition: hps.h:47808
Definition: hps.h:22306
Definition: hps.h:29986
Definition: hps.h:1084
HPS::Type ObjectType() const
Definition: hps.h:18528
Definition: hps.h:13435
Scope
Definition: hps.h:561
std::vector< PortfolioKey, Allocator< PortfolioKey > > PortfolioKeyArray
Array of type HPS::PortfolioKey.
Definition: hps.h:6700
A unitless linear scaling factor. A value of 2.0 will cause lines to be rendered twice as thick...
Definition: hps.h:48940
Definition: hps.h:36155
HPS::Type ObjectType() const
Definition: hps.h:39376
Definition: hps.h:13776
Quality
Definition: hps.h:1074
static const float Infinity
Definition: hps.h:2391
HPS::Type ObjectType() const
Definition: hps.h:27793
Definition: hps.h:5990
std::vector< ImageDefinition, Allocator< ImageDefinition > > ImageDefinitionArray
Array of type HPS::ImageDefinition.
Definition: hps.h:6716
ReferenceFrame
Definition: hps.h:1585
static HPS_INLINE bool IsNAN(float const &a)
Definition: hps.h:2404
HPS::Type ObjectType() const
Definition: hps.h:15072
HPS::Type ObjectType() const
Definition: hps.h:29936
WindowPoint Location
Location in window space for this Touch.
Definition: hps.h:6663
HPS::Type ObjectType() const
Definition: hps.h:39690
HPS::Type ObjectType() const
Definition: hps.h:42794
SizeToleranceUnits
Definition: hps.h:1661
Action
Definition: hps.h:48219
The leader line position is supplied in Object Space.
HPS_INLINE void Merge(Cuboid_3D const &cuboid)
Definition: hps.h:4094
Definition: hps.h:48588
Definition: hps.h:9060
AppendMode
Definition: hps.h:340
Definition: hps.h:43934
Definition: hps.h:41976
Definition: hps.h:11719
Cuboid_3D(size_t count, T const *indices, Point_3D< F > const *points)
Definition: hps.h:3952
std::vector< PointArrayArray, Allocator< PointArrayArray > > PointArrayArrayArray
Array of type HPS::PointArrayArray.
Definition: hps.h:6738
Border
Definition: hps.h:274
size_t display_list_line_3d_count
Number of lines drawn from display lists during the last update.
Definition: hps.h:5066
HPS::Type ObjectType() const
Definition: hps.h:5995
Definition: hps.h:50791
Definition: hps.h:2797
Definition: hps.h:50487
Definition: hps.h:573
virtual HPS::Type Type() const
Definition: hps.h:5993
KeyboardEvent(Event const &in_event)
Definition: hps.h:48395
void RightControl(bool in_state)
Definition: hps.h:47709
Definition: hps.h:23551
Definition: hps.h:39301
std::vector< MaterialKit, Allocator< MaterialKit > > MaterialKitArray
Array of type HPS::MaterialKit.
Definition: hps.h:6706
bool operator!=(ShapeCoordinate const &in_that) const
Definition: hps.h:6810
UpdateStatus
Definition: hps.h:168
HPS::Type ObjectType() const
Definition: hps.h:9432
Definition: hps.h:2710
Definition: hps.h:33444
Definition: hps.h:42023
HPS::Type ObjectType() const
Definition: hps.h:29341
Definition: hps.h:50834
Definition: hps.h:4539
CoordinateSpace
Definition: hps.h:1747
HPS::Type ObjectType() const
Definition: hps.h:45378
Definition: hps.h:42300
Definition: hps.h:41408
GreekingMode
Definition: hps.h:1699
FocusLostEvent()
Definition: hps.h:47346
Definition: hps.h:10158
Definition: hps.h:51732
Definition: hps.h:44725
bool operator!=(GlyphPoint const &in_that) const
Definition: hps.h:5353
Definition: hps.h:6178
UTF8 message
The error message for this ErrorEvent.
Definition: hps.h:47261
Definition: hps.h:1104
static HPS_INLINE bool IsAbnormal(float const &a)
Definition: hps.h:2412
std::vector< RGBColor, Allocator< RGBColor > > RGBColorArray
Array of type HPS::RGBColor.
Definition: hps.h:6684
HPS::Type ObjectType() const
Definition: hps.h:28831
Event * Clone() const
Definition: hps.h:47354
virtual bool Equals(MouseEvent const &in_that) const
Definition: hps.h:48294
Definition: hps.h:49117
Definition: hps.h:48213
Space
Definition: hps.h:2219
ShowKeyboardEvent(Event const &in_event)
Definition: hps.h:47518
ErrorEvent()
Definition: hps.h:47200
Definition: hps.h:47267
std::vector< UTF8Array, Allocator< UTF8Array > > UTF8ArrayArray
Array of type HPS::UTF8Array.
Definition: hps.h:6696
Definition: hps.h:6878
HPS::Type ObjectType() const
Definition: hps.h:15495
virtual HPS::Type Type() const
Definition: hps.h:38736
Definition: hps.h:39432
static ModifierKeys KeyRightMeta()
Definition: hps.h:47820
An InvalidOperationException is thrown when an operation is not supported on the current platform...
Definition: hps.h:5883
Definition: hps.h:39489
Definition: hps.h:49218
Definition: hps.h:41179
RelationTest
Definition: hps.h:395
UpdateCompletedEvent(Event const &in_event)
Definition: hps.h:47439
Definition: hps.h:47914
virtual HPS::Type Type() const
Definition: hps.h:18621
Definition: hps.h:2351
Definition: hps.h:9959
Definition: hps.h:26379
Definition: hps.h:13177
bool RightMeta() const
Definition: hps.h:47654
Definition: hps.h:24050
HPS::Type ObjectType() const
Definition: hps.h:12825
RenderingAlgorithm
Definition: hps.h:50912
Definition: hps.h:46774
static ModifierKeys KeyRightControl()
Definition: hps.h:47804
bool LeftControl() const
Definition: hps.h:47642
Definition: hps.h:43103
Definition: hps.h:50152
HPS::Type ObjectType() const
Definition: hps.h:21966
Definition: hps.h:1775
Renderer
Definition: hps.h:1620
TextInputEvent(Event const &in_event)
Definition: hps.h:47376
Definition: hps.h:1517
HPS::Type ObjectType() const
Definition: hps.h:24829
bool None() const
Definition: hps.h:48091
std::vector< Line::SizeUnits, Allocator< Line::SizeUnits > > LineSizeUnitsArray
Array of type HPS::Line::SizeUnits.
Definition: hps.h:6711
Method
Definition: hps.h:1474
GatheringLevel
Definition: hps.h:1847
Definition: hps.h:326
Definition: hps.h:1449
HPS::Type ObjectType() const
Definition: hps.h:9200
HPS::Type ObjectType() const
Definition: hps.h:45487
HPS::Type ObjectType() const
Definition: hps.h:42010
Definition: hps.h:49934
ColorSource
Definition: hps.h:2035
Definition: hps.h:47362
std::vector< ShapeDefinition, Allocator< ShapeDefinition > > ShapeDefinitionArray
Array of type HPS::ShapeDefinition.
Definition: hps.h:6722
HPS::Type ObjectType() const
Definition: hps.h:39278
CappingLevel
Definition: hps.h:1814
Definition: hps.h:19502
std::vector< LinePatternParallelKit, Allocator< LinePatternParallelKit > > LinePatternParallelKitArray
Array of type HPS::LinePatternParallelKit.
Definition: hps.h:6708
HPS::Type ObjectType() const
Definition: hps.h:22684
Definition: hps.h:40660
Definition: hps.h:49232
HPS::KeyboardCodeArray KeyboardCodes
Array of keyboard codes for this KeyboardEvent.
Definition: hps.h:48469
ResolutionUnits
Definition: hps.h:50896
virtual HPS::Type Type() const
Definition: hps.h:15398
Relation
Definition: hps.h:385
Definition: hps.h:1468
HPS::Type ObjectType() const
Definition: hps.h:42636
WorldPoint(Point const &in_point)
Definition: hps.h:6102
HPS::TouchArray Touches
Array of Touches for this TouchEvent.
Definition: hps.h:48043
Definition: hps.h:51695
std::vector< DVector, Allocator< DVector > > DVectorArray
Array of type HPS::DVector.
Definition: hps.h:6681
Definition: hps.h:49160
HPS::Type ObjectType() const
Definition: hps.h:10639
virtual HPS::Type Type() const
Definition: hps.h:24073
std::vector< Drawing::ClipSpace, Allocator< Drawing::ClipSpace > > ClipSpaceArray
Array of type HPS::Drawing::ClipSpace.
Definition: hps.h:6739
static HPS_INLINE bool Equals(float const &a, float const &b, int tolerance=32)
Definition: hps.h:2630
Definition: hps.h:25230
HPS::Type ObjectType() const
Definition: hps.h:7040
Definition: hps.h:39006
Definition: hps.h:19827
void LeftAlt(bool in_state)
Definition: hps.h:47721
TouchEvent(Event const &in_event)
Definition: hps.h:47956
friend bool operator!=(char const *in_left, UTF8 const &in_right)
Definition: hps.h:7326
Definition: hps.h:5324
Definition: hps.h:45001
Definition: hps.h:51727
Definition: hps.h:41265
HPS::Type ObjectType() const
Definition: hps.h:41304
size_t save_region_count
Number of framebuffer regions saved during the last update.
Definition: hps.h:5077
Definition: hps.h:39656
Definition: hps.h:4478
std::vector< GlyphElement, Allocator< GlyphElement > > GlyphElementArray
Array of type HPS::GlyphElement.
Definition: hps.h:6692
void LeftControl(bool in_state)
Definition: hps.h:47713
HPS::Type ObjectType() const
Definition: hps.h:25350
Definition: hps.h:7139
IOResult result
Enumeration indicating the category of the exception.
Definition: hps.h:5900
HPS::Type ObjectType() const
Definition: hps.h:44428
HPS::Type ObjectType() const
Definition: hps.h:45215
Definition: hps.h:26655
Definition: hps.h:6137
HPS::Type ObjectType() const
Definition: hps.h:49143
bool Alt() const
Definition: hps.h:47610
Definition: hps.h:48059
virtual HPS::Type Type() const
Definition: hps.h:20717
Definition: hps.h:27439
virtual HPS::Type Type() const
Definition: hps.h:19771
Definition: hps.h:30211
HPS::Type ObjectType() const
Definition: hps.h:13723
std::vector< float, Allocator< float > > FloatArray
Array of type float.
Definition: hps.h:6688
virtual HPS::Type Type() const
Definition: hps.h:23724
Definition: hps.h:6752
HPS::Type ObjectType() const
Definition: hps.h:19667
HPS::Type ObjectType() const
Definition: hps.h:39746
Definition: hps.h:44904
Definition: hps.h:9110
virtual HPS::Type Type() const
Definition: hps.h:13948
virtual HPS::Type Type() const
Definition: hps.h:22329
Definition: hps.h:49680
Event * Clone() const
Definition: hps.h:47557
HPS::Type ObjectType() const
Definition: hps.h:16285
Grid composed of quadrilaterals.
FrameOptions
Definition: hps.h:223
Definition: hps.h:6095
Visualize will perform runtime query of the 3D capabilities of the Operating System and graphics card...
HPS::Type ObjectType() const
Definition: hps.h:7116
HPS::KeyboardEvent::Action CurrentAction
The action for the keyboard codes for this KeyboardEvent.
Definition: hps.h:48470
Definition: hps.h:46954
HPS::Type ObjectType() const
Definition: hps.h:20720
virtual HPS::Type Type() const
Definition: hps.h:14576
Definition: hps.h:45765
virtual HPS::Type Type() const
Definition: hps.h:46231
Definition: hps.h:43984
HPS::Type ObjectType() const
Definition: hps.h:45655
Definition: hps.h:28265
virtual HPS::Type Type() const
Definition: hps.h:42791
Definition: hps.h:48475
std::vector< MatrixKit, Allocator< MatrixKit > > MatrixKitArray
Array of type HPS::MatrixKit.
Definition: hps.h:6741
Operation
Definition: hps.h:460
An InvalidLicenseException is thrown when trying to run Visualize with an invalid license...
Definition: hps.h:5874
float blue
Definition: hps.h:4544
Definition: hps.h:47342
Definition: sprk_dwg.h:43
HPS::Type ObjectType() const
Definition: hps.h:23575
Driver
Definition: hps.h:154
Multiline strings will be left justified.
std::vector< NamedStyleDefinition, Allocator< NamedStyleDefinition > > NamedStyleDefinitionArray
Array of type HPS::NamedStyleDefinition.
Definition: hps.h:6717
friend bool operator!=(wchar_t const *in_left, UTF8 const &in_right)
Definition: hps.h:7344
PixelPoint(Point const &in_point)
Definition: hps.h:6310
HPS::Type ObjectType() const
Definition: hps.h:6425
virtual HPS::Type Type() const
Definition: hps.h:15671
std::vector< InnerPixelPoint, Allocator< InnerPixelPoint > > InnerPixelPointArray
Array of type HPS::InnerPixelPoint.
Definition: hps.h:6677
Mode
Definition: hps.h:1804
static ModifierKeys KeyRightShift()
Definition: hps.h:47796
Definition: hps.h:19642
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:48320
Definition: hps.h:23402
std::vector< WindowPoint, Allocator< WindowPoint > > WindowPointArray
Array of type HPS::WindowPoint.
Definition: hps.h:6678
Default
Definition: hps.h:2045
Definition: hps.h:50743
size_t non_display_list_tristrip_count
Number of tristrips drawn during the last update.
Definition: hps.h:5070
HPS::Type ObjectType() const
Definition: hps.h:24203
size_t display_list_vertex_3d_count
Number of vertices drawn from display lists during the last update.
Definition: hps.h:5068
HPS::Type ObjectType() const
Definition: hps.h:24076
HPS::Type ObjectType() const
Definition: hps.h:39642
Code
Definition: hps.h:99
HPS::Type ObjectType() const
Definition: hps.h:31828
UpdateCompletedEvent(Time in_update_time, Window::UpdateStatus in_update_status)
Definition: hps.h:47435
HPS::Type ObjectType() const
Definition: hps.h:26951
HPS::Type ObjectType() const
Definition: hps.h:44852
HPS::Type ObjectType() const
Definition: hps.h:23426
HPS::MouseEvent::Action CurrentAction
The action for this MouseEvent.
Definition: hps.h:48340
Event * Clone() const
Definition: hps.h:47498
Definition: hps.h:15804
Algorithm
Definition: hps.h:1353
bool RightControl() const
Definition: hps.h:47638
Object space units ignoring any scaling components in modelling matrices.
bool operator==(GlyphPoint const &in_that) const
Definition: hps.h:5347
bool LeftAlt() const
Definition: hps.h:47650
Definition: hps.h:40303
virtual HPS::Type Type() const
Definition: hps.h:10636
Definition: hps.h:47428
HPS::Type ObjectType() const
Definition: hps.h:38739
HPS::Type ObjectType() const
Definition: hps.h:46907
Definition: hps.h:41025
Definition: hps.h:50334
HPS::Type ObjectType() const
Definition: hps.h:17612
Definition: hps.h:2019
std::vector< int, Allocator< int > > IntArray
Array of type int.
Definition: hps.h:6683
Definition: hps.h:34828
HPS::Type ObjectType() const
Definition: hps.h:45792
size_t line_3d_count
Number of 3D lines drawn during the last update.
Definition: hps.h:5059
std::vector< GlyphDefinition, Allocator< GlyphDefinition > > GlyphDefinitionArray
Array of type HPS::GlpyhDefinition.
Definition: hps.h:6719
bool LeftMeta() const
Definition: hps.h:47658
Fastest ambient occlusion but lower quality.
intptr_t GetChannel() const
Definition: hps.h:6378
HPS::Type ObjectType() const
Definition: hps.h:9984
Definition: hps.h:1366
Definition: hps.h:15047
ImageFormat
Definition: hps.h:231
bool NumLock() const
Definition: hps.h:47622
Definition: hps.h:49707
HPS::Type ObjectType() const
Definition: hps.h:34851
Definition: hps.h:49907
HPS::Type ObjectType() const
Definition: hps.h:43137
HPS_INLINE bool Intersecting(Cuboid_3D const &cuboid, F const allowance) const
Definition: hps.h:4039
Definition: hps.h:13697
Definition: hps.h:49467
intptr_t GetClassID() const
Definition: hps.h:11466
Definition: hps.h:7388
HPS::Type ObjectType() const
Definition: hps.h:41146
Definition: hps.h:48797
StandAloneWindowEvent()
Definition: hps.h:47282
HPS::Type ObjectType() const
Definition: hps.h:41506
HPS::Type ObjectType() const
Definition: hps.h:38558
ModifierKeys GetModifierKeys() const
Definition: hps.h:47905
Definition: hps.h:47566
Definition: hps.h:45183
TextInputEvent(char const *in_text)
Definition: hps.h:47372
A unitless linear scaling factor. A value of 2.0 will cause edges to be rendered twice as thick...
Definition: hps.h:47125
HPS::Type ObjectType() const
Definition: hps.h:41062
Projection
Definition: hps.h:1435
bool RightShift() const
Definition: hps.h:47630
HPS::Type ObjectType() const
Definition: hps.h:13554
HPS::Type ObjectType() const
Definition: hps.h:12145
SizeUnits
Definition: hps.h:50889
Definition: hps.h:49894
virtual bool Equals(WarningEvent const &in_that) const
Definition: hps.h:47169
HPS::Type ObjectType() const
Definition: hps.h:49067
virtual HPS::Type Type() const
Definition: hps.h:21725
MouseEvent(Action in_action, WindowPoint in_location, MouseButtons in_button=MouseButtons(), ModifierKeys in_modifier=ModifierKeys(), size_t in_click_count=0)
Definition: hps.h:48238
An InvalidObjectException is thrown when a user tries to interact with an object that either is unini...
Definition: hps.h:5846
HPS::Type ObjectType() const
Definition: hps.h:19365
Preference
Definition: hps.h:1629
InsetBehavior
Definition: hps.h:1914
virtual bool Equals(InformationEvent const &in_that) const
Definition: hps.h:47098
bool X2() const
Definition: hps.h:48111
bool Equals(ModifierKeys const &in_that) const
Definition: hps.h:47575
Definition: hps.h:38535
Definition: hps.h:51604
bool Left() const
Definition: hps.h:48095
void Control(bool in_state)
Definition: hps.h:47677
Definition: hps.h:24170
Definition: hps.h:51152
Algorithm
Definition: hps.h:1483
Definition: hps.h:3057
Interpolation
Definition: hps.h:1017
Definition: hps.h:18912
Definition: hps.h:47856
HPS::Type ObjectType() const
Definition: hps.h:50772
Object space units ignoring any scaling components in modelling matrices.
HPS::Type ObjectType() const
Definition: hps.h:20126
HPS_INLINE bool Contains(Point_3D< F > const &contained) const
Definition: hps.h:4180
UTF8 message
The warning message for this WarningEvent.
Definition: hps.h:47190
Preference
Definition: hps.h:1505
The base class of all HPS exceptions.
Definition: hps.h:5838
TouchEvent(Action in_action, size_t in_touch_count, Touch const in_touches[], ModifierKeys in_modifier=ModifierKeys())
Definition: hps.h:47950
std::vector< Style::Type, Allocator< Style::Type > > StyleTypeArray
Array of type HPS::Style::Type.
Definition: hps.h:6725
Event * Clone() const
Definition: hps.h:48275
std::vector< StyleKey, Allocator< StyleKey > > StyleKeyArray
Array of type HPS::StyleKey.
Definition: hps.h:6735
Definition: hps.h:6345
HPS::Type ObjectType() const
Definition: hps.h:23727
Definition: hps.h:42561
InformationEvent(Event const &in_event)
Definition: hps.h:47071
Definition: hps.h:14052
void Invalidate()
Definition: hps.h:3984
bool Equals(ShapePoint const &in_that) const
Definition: hps.h:6859
Definition: hps.h:25749
Definition: hps.h:44402
Quaternion Spline(Quaternion const &in_previous, Quaternion const &in_next) const
Definition: hps.h:5044
IOException(char const *in_info, IOResult in_result)
Definition: hps.h:5897
Definition: hps.h:40969
Definition: hps.h:48860
std::vector< UTF8, Allocator< UTF8 > > UTF8Array
Array of type HPS::UTF8.
Definition: hps.h:6695
The geometry inside the clip region is drawn. Everything outside of it is clipped.
virtual HPS::Type Type() const
Definition: hps.h:13395
HPS::Type ObjectType() const
Definition: hps.h:38042
Justification
Definition: hps.h:1950
size_t restore_region_count
Number of framebuffer regions restored during the last update.
Definition: hps.h:5078
Definition: hps.h:49974
Material Texture ChannelMapping.
GreekingUnits
Definition: hps.h:1687
Definition: hps.h:6303
HPS::Type ObjectType() const
Definition: hps.h:46127
virtual HPS::Type Type() const
Definition: hps.h:45844
Value
Definition: hps.h:1455
SizeUnits
Definition: hps.h:1529
HPS::Type ObjectType() const
Definition: hps.h:41385
HPS::ByteArray non_db_user_data
Definition: hps.h:49170
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:6371
Definition: hps.h:408
The vertex colors applied to faces.
ClipOperation
Definition: hps.h:1326
std::vector< Touch, Allocator< Touch > > TouchArray
Array of type HPS::Touch.
Definition: hps.h:6730
std::vector< InnerWindowPoint, Allocator< InnerWindowPoint > > InnerWindowPointArray
Array of type HPS::InnerWindowPoint.
Definition: hps.h:6676
std::vector< intptr_t, Allocator< intptr_t > > IntPtrTArray
Array of type intptr_t.
Definition: hps.h:6732
HPS::Type ObjectType() const
Definition: hps.h:40795
char const * GetBytes() const
Definition: hps.h:7230
MarginUnits
Definition: hps.h:1674
virtual intptr_t Freshen() const
Definition: hps.h:48332
Definition: hps.h:38415
virtual bool Equals(TextInputEvent const &in_that) const
Definition: hps.h:47392
Event * Clone() const
Definition: hps.h:47417
HPS::Type ObjectType() const
Definition: hps.h:39786
InputEvent(ModifierKeys const &in_modifiers)
Definition: hps.h:47865
std::vector< Shell::Relation, Allocator< Shell::Relation > > ShellRelationArray
Array of type HPS::ShelL::Relation.
Definition: hps.h:6734
float green
Definition: hps.h:4543
HPS::Type ObjectType() const
Definition: hps.h:41003
Algorithm
Definition: hps.h:1400
HPS::Type ObjectType() const
Definition: hps.h:11089
Definition: hps.h:41111
HPS::Type ObjectType() const
Definition: hps.h:30009
HPS::Type ObjectType() const
Definition: hps.h:27472
HandleResult
Definition: hps.h:46938
size_t triangle_dc_count
Number of DC triangles drawn during the last update.
Definition: hps.h:5060
HPS::Type ObjectType() const
Definition: hps.h:27227
static void * Allocate(size_t in_bytes, bool in_clear_memory=true)
HPS::Type ObjectType() const
Definition: hps.h:45561
Definition: hps.h:11288
HPS::Type ObjectType() const
Definition: hps.h:43190
HPS::Type ObjectType() const
Definition: hps.h:27594
Status
Definition: hps.h:6351
InnerPixelPoint(Point const &in_point)
Definition: hps.h:6227
HPS::Type ObjectType() const
Definition: hps.h:51180
ImportStatusEvent(Event const &in_event)
Definition: hps.h:47483
Component
Definition: hps.h:414
bool RightAlt() const
Definition: hps.h:47646
Definition: sprk_parasolid.h:39
Touch(TouchID in_id, WindowPoint const &in_location, size_t in_tap_count=1)
Definition: hps.h:6643
Type
Definition: hps.h:332
Definition: hps.h:49261
static const float NegativeInfinity
Definition: hps.h:2393
Definition: hps.h:49352
HighlightEvent(Event const &in_event)
Definition: hps.h:47025
friend bool operator==(wchar_t const *in_left, UTF8 const &in_right)
Definition: hps.h:7335
HPS::Type ObjectType() const
Definition: hps.h:14077
Justification
Definition: hps.h:1593
HPS::Type ObjectType() const
Definition: hps.h:23082
Definition: hps.h:23828
TextInputEvent()
Definition: hps.h:47366
HPS::MouseButtons CurrentButton
If the action involves a button, this is the button.
Definition: hps.h:48342
HPS::Type ObjectType() const
Definition: hps.h:11313
InnerWindowPoint(Point const &in_point)
Definition: hps.h:6186
HPS::Type ObjectType() const
Definition: hps.h:32040
HPS::Type ObjectType() const
Definition: hps.h:48883
HPS::Info::Code code
The warning code for this InformationEvent.
Definition: hps.h:47120
InnerConeUnits
Definition: hps.h:492
std::vector< KeyboardCode, Allocator< KeyboardCode > > KeyboardCodeArray
Array of type HPS::KeyboardCode.
Definition: hps.h:6729
Definition: hps.h:46879
Cuboid_3D(size_t count, Point_3D< F > const *points)
Definition: hps.h:3934
Definition: hps.h:13591
virtual HPS::Type Type() const
Definition: hps.h:12822
HPS::Type ObjectType() const
Definition: hps.h:51681
HPS::Type ObjectType() const
Definition: hps.h:39470
std::vector< Key, Allocator< Key > > KeyArray
Array of type HPS::Key.
Definition: hps.h:6699
void Alt(bool in_state)
Definition: hps.h:47681
Definition: hps.h:2126
Buttons
Definition: hps.h:48199
KeyboardEvent(KeyboardEvent::Action in_action, ModifierKeys in_modifiers=ModifierKeys())
Definition: hps.h:48367
HPS::Type ObjectType() const
Definition: hps.h:42345
HideKeyboardEvent(Event const &in_event)
Definition: hps.h:47547
bool operator!=(Touch const &in_that) const
Definition: hps.h:6657
Definition: hps.h:46479
Definition: hps.h:26844
Definition: hps.h:93
HPS::Type ObjectType() const
Definition: hps.h:50221
HPS::Type ObjectType() const
Definition: hps.h:51867
Granularity
Definition: hps.h:1413
HPS::Type ObjectType() const
Definition: hps.h:51755
HPS::Type ObjectType() const
Definition: hps.h:37772
WorldPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:6099
Percentage of the requested font height.
HPS::Type ObjectType() const
Definition: hps.h:10183
HPS::Type ObjectType() const
Definition: hps.h:51954
friend bool operator==(char const *in_left, UTF8 const &in_right)
Definition: hps.h:7317
ShowKeyboardEvent()
Definition: hps.h:47512
Definition: hps.h:26104
Style Append Mode.
HPS::SegmentKey & segment_key
Definition: hps.h:49212
std::vector< Plane, Allocator< Plane > > PlaneArray
Array of type HPS::Plane.
Definition: hps.h:6682
Definition: hps.h:49174
Definition: hps.h:39353
Definition: hps.h:1289
Channel
Definition: hps.h:907
Event * Clone() const
Definition: hps.h:47975
std::vector< unsigned int, Allocator< unsigned int > > UnsignedIntArray
Array of type unsigned int.
Definition: hps.h:6686
void Middle(bool in_state)
Definition: hps.h:48134
Definition: hps.h:32017
virtual bool Equals(ErrorEvent const &in_that) const
Definition: hps.h:47240
Definition: hps.h:5052
Action
Definition: hps.h:48354
Event * Clone() const
Definition: hps.h:47308
Definition: hps.h:50001
size_t GetLength() const
Definition: hps.h:7215
HPS::Type ObjectType() const
Definition: hps.h:23516
HPS::Type ObjectType() const
Definition: hps.h:29557
Type
Definition: hps.h:1152
Definition: hps.h:427
HPS::Type ObjectType() const
Definition: hps.h:10095
bool None() const
Definition: hps.h:47598
std::vector< char, Allocator< char > > CharArray
Array of type char.
Definition: hps.h:6701
InterpolationAlgorithm
Definition: hps.h:1552
size_t ClickCount
The number of clicks received.
Definition: hps.h:48344
Percentage of the requested font size defining the lower limit on the smallest font size that can be ...
virtual intptr_t Freshen() const
Definition: hps.h:6375
void Reset()
Definition: hps.h:7210
HPS::Type ObjectType() const
Definition: hps.h:42919
HPS::Type ObjectType() const
Definition: hps.h:26603
Definition: hps.h:38287
Action
Definition: hps.h:47273
Code
Definition: hps.h:131
HPS::Type ObjectType() const
Definition: hps.h:46234
Preference
Definition: hps.h:2261
Definition: hps.h:44828
Definition: hps.h:50168
static ModifierKeys KeyNumLock()
Definition: hps.h:47788
Event * Clone() const
Definition: hps.h:47231
MouseEvent(Event const &in_event)
Definition: hps.h:48253
bool Right() const
Definition: hps.h:48099
Definition: hps.h:2146
Handedness
Definition: hps.h:1295
virtual bool Empty() const
Definition: hps.h:5947
HPS_INLINE void Merge(Sphere_3D< F > const &sphere)
Definition: hps.h:4108
virtual HPS::Type Type() const
Definition: hps.h:6026
static MouseButtons ButtonLeft()
Definition: hps.h:48177
std::vector< CameraPoint, Allocator< CameraPoint > > CameraPointArray
Array of type HPS::CameraPoint.
Definition: hps.h:6675
Type
Definition: hps.h:451
virtual HPS::Type Type() const
Definition: hps.h:20123
size_t dot_dc_count
Number of DC dots drawn during the last update.
Definition: hps.h:5056
static MouseButtons ButtonMiddle()
Definition: hps.h:48185
TouchEvent(Action in_action, ModifierKeys in_modifier=ModifierKeys())
Definition: hps.h:47933
virtual HPS::Type Type() const
Definition: hps.h:18525
Capping
Definition: hps.h:527
static intptr_t ClassID()
Definition: hps.h:5974
size_t deferred_3d_items_created
Number of deferred items created during the last update.
Definition: hps.h:5080
HighlightEvent()
Definition: hps.h:47009
virtual HPS::Type Type() const
Definition: hps.h:16121
virtual HPS::Type ObjectType() const
Definition: hps.h:5941
Definition: hps.h:49287
Definition: hps.h:20999
HPS::Type ObjectType() const
Definition: hps.h:15277
Definition: hps.h:31666
Definition: hps.h:18599
void RightAlt(bool in_state)
Definition: hps.h:47717
HPS::TouchEvent::Action CurrentAction
The action for the touches of this TouchEvent.
Definition: hps.h:48042
UpdateType
Definition: hps.h:180
Definition: hps.h:9170
Type
Definition: hps.h:596
virtual intptr_t Freshen() const
Definition: hps.h:46992
Component
Definition: hps.h:359
HPS_INLINE bool Intersecting(Cuboid_3D const &cuboid) const
Definition: hps.h:4028
Format
Definition: hps.h:42305
std::vector< ConditionalExpression, Allocator< ConditionalExpression > > ConditionalExpressionArray
Array of type HPS::ConditionalExpression.
Definition: hps.h:6713
Definition: hps.h:50919
CuttingLevel
Definition: hps.h:1831
static ModifierKeys KeyControl()
Definition: hps.h:47770
SizeUnits
Definition: hps.h:1649
Level
Definition: hps.h:1372
std::vector< IntRectangle, Allocator< IntRectangle > > IntRectangleArray
Array of type HPS::IntRectangle.
Definition: hps.h:6723
HPS::Type ObjectType() const
Definition: hps.h:20379
Definition: hps.h:5856
HPS::Type ObjectType() const
Definition: hps.h:40064
Definition: hps.h:7686
Definition: hps.h:49827
HPS::Type ObjectType() const
Definition: hps.h:45847
Default
Definition: hps.h:1981
StandAloneWindowEvent(Action in_action)
Definition: hps.h:47287
Definition: hps.h:37408
size_t segment_count
Number of segments traversed during the last update.
Definition: hps.h:5073
Definition: hps.h:12119
UTF8 message
The warning information for this WarningEvent.
Definition: hps.h:47119
Event * Clone() const
Definition: hps.h:47457
The vertex colors applied to faces.
Definition: hps.h:38148
size_t polygon_3d_count
Number of 3D polygons drawn during the last update.
Definition: hps.h:5063
HPS_INLINE Cuboid_3D & Expand(F border)
Definition: hps.h:4239
virtual bool Equals(InputEvent const &in_that) const
Definition: hps.h:48423
std::vector< TrimKit, Allocator< TrimKit > > TrimKitArray
Array of type HPS::TrimKit.
Definition: hps.h:6698
HPS_INLINE bool Intersecting(int dimension, Cuboid_3D const &cuboid, F const allowance) const
Definition: hps.h:4063
Definition: hps.h:38009
virtual HPS::Type Type() const
Definition: hps.h:18847
size_t display_list_triangle_3d_count
Number of triangles drawn from display lists during the last update.
Definition: hps.h:5067
Definition: hps.h:353
bool operator==(ShapeCoordinate const &in_that) const
Definition: hps.h:6805
Definition: hps.h:16259
Definition: hps.h:23908
virtual HPS::Type Type() const
Definition: hps.h:13720
std::vector< sbyte, Allocator< sbyte > > SByteArray
Array of type HPS::sbyte.
Definition: hps.h:6705
std::vector< Drawing::ClipOperation, Allocator< Drawing::ClipOperation > > ClipOperationArray
Array of type HPS::Drawing::ClipOperation.
Definition: hps.h:6740
HPS_INLINE Vector_3D< F > Diagonal() const
Definition: hps.h:4016
Definition: hps.h:923
Event * Clone() const
Definition: hps.h:47528
HPS::Type ObjectType() const
Definition: hps.h:13460
std::vector< Point, Allocator< Point > > PointArray
Array of type HPS::Point.
Definition: hps.h:6672
Time static_time
Time taken to create the static model(s) during the last update.
Definition: hps.h:5055
Definition: hps.h:40247
HPS::Type ObjectType() const
Definition: hps.h:36189
HPS::Type ObjectType() const
Definition: hps.h:19774
Definition: hps.h:49110
virtual HPS::Type Type() const
Definition: hps.h:13551
HPS::Type ObjectType() const
Definition: hps.h:43019
AreaUnits
Definition: hps.h:1496
Definition: hps.h:39898
HPS::Type ObjectType() const
Definition: hps.h:50357
HandednessOptimization
Definition: hps.h:376
size_t deferred_inplace_items
Number of InPlace items deferred.
Definition: hps.h:5082
HPS::Type ObjectType() const
Definition: hps.h:48713
HPS_INLINE void Generate_Cuboid_Points(Point_3D< F > *points) const
Definition: hps.h:4002
HPS::Type ObjectType() const
Definition: hps.h:42111
static ModifierKeys KeyRightAlt()
Definition: hps.h:47812
Definition: hps.h:40185
HPS::Type ObjectType() const
Definition: hps.h:13616
std::vector< Line::CoordinateSpace, Allocator< Line::CoordinateSpace > > LineCoordinateSpaceArray
Array of type HPS::Line::CoordinateSpace.
Definition: hps.h:6743
HPS::Type ObjectType() const
Definition: hps.h:19852
Definition: hps.h:26928
Definition: hps.h:9399
Event * Clone() const
Definition: hps.h:48414
Definition: hps.h:11064
HPS_INLINE bool Intersecting(Point_3D< F > const &start, Vector_3D< F > const &direction) const
Definition: hps.h:4074
RegionFitting
Definition: hps.h:1725
HPS_INLINE Cuboid_3D & Union(Cuboid_3D const &cuboid)
Definition: hps.h:4224
WindowPoint(Point const &in_point)
Definition: hps.h:6269
HPS::Type ObjectType() const
Definition: hps.h:42459
Definition: hps.h:12405
Alignment
Definition: hps.h:1570
Definition: hps.h:9093
HPS::Key & key
Definition: hps.h:49198
Definition: hps.h:47054
A grid of lines will be drawn in place of characters below the greeking limit.
Definition: hps.h:45355
virtual HPS::Type Type() const
Definition: hps.h:39175
Definition: hps.h:24604
Definition: hps.h:39609
std::vector< WorldPoint, Allocator< WorldPoint > > WorldPointArray
Array of type HPS::WorldPoint.
Definition: hps.h:6674
std::vector< RGBAColor, Allocator< RGBAColor > > RGBAColorArray
Array of type HPS::RGBAColor.
Definition: hps.h:6685
Definition: hps.h:30323
Definition: hps.h:24966
HPS::Type ObjectType() const
Definition: hps.h:44007
Definition: hps.h:555
Definition: hps.h:28808
Type
Definition: hps.h:890
bool operator==(ShapePoint const &in_that) const
Definition: hps.h:6864
Definition: hps.h:942
ModifierKeys()
Definition: hps.h:47570
Definition: hps.h:27845
static ModifierKeys KeyLeftShift()
Definition: hps.h:47800
Definition: hps.h:1895
std::vector< HighlightState, Allocator< HighlightState > > HighlightStateArray
Array of type HPS::HighlightState.
Definition: hps.h:6745
Definition: hps.h:25327
Definition: hps.h:31037
size_t deferred_sprite_items
Number of Spriting items deferred.
Definition: hps.h:5083
Definition: hps.h:49188
Tiling
Definition: hps.h:998
Material Texture ChannelMapping.
HPS::Type ObjectType() const
Definition: hps.h:28149
Definition: hps.h:47196
HPS::Type ObjectType() const
Definition: hps.h:39860
TouchEvent()
Definition: hps.h:47927
Definition: hps.h:43635
HPS::Type ObjectType() const
Definition: hps.h:22332
virtual bool Equals(InputEvent const &in_that) const
Definition: hps.h:47880
void LeftShift(bool in_state)
Definition: hps.h:47705
std::vector< AttributeLock::Type, Allocator< AttributeLock::Type > > AttributeLockTypeArray
Array of type HPS::AttributeLock.
Definition: hps.h:6724
HPS::Type ObjectType() const
Definition: hps.h:23268
Modifiers
Definition: hps.h:47830
Definition: hps.h:513
Definition: hps.h:10613
BackgroundPreference
Definition: hps.h:50905
std::vector< TextureDefinition, Allocator< TextureDefinition > > TextureDefinitionArray
Array of type HPS::TexureDefinition.
Definition: hps.h:6714
Definition: hps.h:42767
HPS::Type ObjectType() const
Definition: hps.h:40376
HPS::Type ObjectType() const
Definition: hps.h:6903
HPS::Type ObjectType() const
Definition: hps.h:25263
Definition: hps.h:19340
HPS_INLINE Cuboid_3D & Intersect(Cuboid_3D const &cuboid)
Definition: hps.h:4209
HPS::Type ObjectType() const
Definition: hps.h:50947
Definition: hps.h:41342
HPS::Type ObjectType() const
Definition: hps.h:25052
Definition: hps.h:3343
WarningEvent()
Definition: hps.h:47129
std::vector< CubeMapDefinition, Allocator< CubeMapDefinition > > CubeMapDefinitionArray
Array of type HPS::CubeMapDefinition.
Definition: hps.h:6715
bool operator!=(ShapePoint const &in_that) const
Definition: hps.h:6869
Definition: hps.h:27760
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:46986
HPS::Type ObjectType() const
Definition: hps.h:40885
Touch()
Definition: hps.h:6637
Definition: hps.h:13372
std::vector< GeometryKey, Allocator< GeometryKey > > GeometryKeyArray
Array of type HPS::GeometryKey.
Definition: hps.h:6733
Channel
Definition: hps.h:929
std::vector< wchar_t, Allocator< wchar_t > > WCharArray
Array of type wchar_t.
Definition: hps.h:6702
Sorting
Definition: hps.h:1381
Definition: hps.h:40342
ChannelMapping
Definition: hps.h:1044
HPS::Type ObjectType() const
Definition: hps.h:6025
size_t polyhedron_count
Number of polyhedra drawn during the last update.
Definition: hps.h:5064
Definition: hps.h:37755
Definition: hps.h:45821
Definition: hps.h:1147
ToleranceUnits
Definition: hps.h:368
Kit & operator=(Kit &&in_that)
Definition: hps.h:6043
float red
Definition: hps.h:4542
Definition: hps.h:13283
virtual HPS::Type Type() const
Definition: hps.h:44425
Definition: hps.h:42985
Definition: hps.h:17586
void NumLock(bool in_state)
Definition: hps.h:47693
Control & operator=(Control &&in_that)
Definition: hps.h:6012
Definition: hps.h:49586
HPS::Type ObjectType() const
Definition: hps.h:15401
Definition: hps.h:31937
Cap
Definition: hps.h:1933
Definition: hps.h:45464
void Right(bool in_state)
Definition: hps.h:48130
virtual void Reset()
Definition: hps.h:46930
Definition: hps.h:12799
Definition: hps.h:50124
HPS::Type ObjectType() const
Definition: hps.h:12284
bool Meta() const
Definition: hps.h:47614
std::vector< ByteArray, Allocator< ByteArray > > ByteArrayArray
Array of type HPS::ByteArray.
Definition: hps.h:6704
Definition: hps.h:49038
HPS_INLINE Cuboid_3D & Contract(F border)
Definition: hps.h:4251
HPS::Type ObjectType() const
Definition: hps.h:41208
Type
Definition: hps.h:2152
Definition: hps.h:39825
TimerTickEvent()
Definition: hps.h:46958
Definition: hps.h:43811
Definition: hps.h:42322
HPS::Type ObjectType() const
Definition: hps.h:24637
EmergencyHandler()
Definition: hps.h:46460
CameraPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:6141
Both cylinder ends will be capped.
TouchID ID
TouchID for this Touch.
Definition: hps.h:6662
static ModifierKeys KeyCapsLock()
Definition: hps.h:47784
Definition: hps.h:41472
HPS::Type ObjectType() const
Definition: hps.h:11745
Space
Definition: hps.h:579
HPS::Type ObjectType() const
Definition: hps.h:37431
HPS::Type ObjectType() const
Definition: hps.h:8849
Definition: hps.h:50884
virtual HPS::Type Type() const
Definition: hps.h:15186
Definition: hps.h:6401
Join
Definition: hps.h:1924
Definition: hps.h:27204
Definition: hps.h:7088
size_t raster_count
Number of rasters drawn during the last update.
Definition: hps.h:5072
HPS::Type ObjectType() const
Definition: hps.h:43669
size_t deleted_display_list_count
Number of deleted display lists during the last update.
Definition: hps.h:5065
Radial bloom.
HPS::Type ObjectType() const
Definition: hps.h:45704
Control(Control &&in_that)
Definition: hps.h:6007
bool Control() const
Definition: hps.h:47606
Definition: hps.h:5763
HPS::Type ObjectType() const
Definition: hps.h:39029
bool CapsLock() const
Definition: hps.h:47618
Type
Definition: hps.h:2113
Definition: hps.h:31805
Definition: hps.h:6219
Definition: hps.h:42436
Rotation
Definition: hps.h:1639
Definition: hps.h:51379
Channel
Definition: hps.h:948
size_t GetHash() const
Driver
Definition: hps.h:51135
Definition: hps.h:24806
HPS::Type ObjectType() const
Definition: hps.h:39178
Action
Definition: hps.h:47919
HPS::Type ObjectType() const
Definition: hps.h:6986
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:48343
Definition: hps.h:42607
Definition: hps.h:50198
std::vector< ReferenceKey, Allocator< ReferenceKey > > ReferenceKeyArray
Array of type HPS::ReferenceKey.
Definition: hps.h:6731
Definition: hps.h:29903
std::vector< GlyphPoint, Allocator< GlyphPoint > > GlyphPointArray
Array of type HPS::GlyphPoint.
Definition: hps.h:6694
Definition: hps.h:2163
virtual HPS::Type Type() const
Definition: hps.h:16282
Definition: hps.h:7397
std::vector< size_t, Allocator< size_t > > SizeTArray
Array of type size_t.
Definition: hps.h:6687
std::vector< ImageKit, Allocator< ImageKit > > ImageKitArray
Array of type HPS::ImageKit.
Definition: hps.h:6746
HPS::Type ObjectType() const
Definition: hps.h:48820
virtual HPS::Type Type() const
Definition: hps.h:11742
Mode
Definition: hps.h:1865
virtual HPS::Type Type() const
Definition: hps.h:22892